xtreemfs/cpp/generated/xtreemfs/OSD.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "xtreemfs/OSD.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* InternalGmax_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  InternalGmax_reflection_ = NULL;
const ::google::protobuf::Descriptor* Lock_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Lock_reflection_ = NULL;
const ::google::protobuf::Descriptor* ObjectData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ObjectData_reflection_ = NULL;
const ::google::protobuf::Descriptor* ObjectList_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ObjectList_reflection_ = NULL;
const ::google::protobuf::Descriptor* ObjectVersion_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ObjectVersion_reflection_ = NULL;
const ::google::protobuf::Descriptor* TruncateRecord_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TruncateRecord_reflection_ = NULL;
const ::google::protobuf::Descriptor* TruncateLog_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  TruncateLog_reflection_ = NULL;
const ::google::protobuf::Descriptor* XLocSetVersionState_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  XLocSetVersionState_reflection_ = NULL;
const ::google::protobuf::Descriptor* ReplicaStatus_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ReplicaStatus_reflection_ = NULL;
const ::google::protobuf::Descriptor* ObjectVersionMapping_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ObjectVersionMapping_reflection_ = NULL;
const ::google::protobuf::Descriptor* AuthoritativeReplicaState_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AuthoritativeReplicaState_reflection_ = NULL;
const ::google::protobuf::Descriptor* InternalReadLocalResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  InternalReadLocalResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* readRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  readRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* truncateRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  truncateRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* unlink_osd_Request_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  unlink_osd_Request_reflection_ = NULL;
const ::google::protobuf::Descriptor* writeRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  writeRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_broadcast_gmaxRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_broadcast_gmaxRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_check_objectRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_check_objectRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_cleanup_get_resultsResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_cleanup_get_resultsResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_cleanup_is_runningResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_cleanup_is_runningResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_cleanup_startRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_cleanup_startRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_cleanup_statusResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_cleanup_statusResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_fetchRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_fetchRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_repair_objectRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_repair_objectRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_flease_msgRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_flease_msgRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_set_primary_epochRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_set_primary_epochRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_statusRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_statusRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_truncateRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_truncateRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_updateRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_updateRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_get_gmaxRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_get_gmaxRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_get_file_sizeRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_get_file_sizeResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_get_file_sizeResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_read_localRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_read_localRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_get_object_setRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_get_object_setRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_internal_get_fileid_listResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_internal_get_fileid_listResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* lockRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  lockRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_pingMesssage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_pingMesssage_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_auth_stateRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_auth_stateRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_rwr_reset_completeRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_rwr_reset_completeRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_xloc_set_invalidateRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* xtreemfs_xloc_set_invalidateResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  xtreemfs_xloc_set_invalidateResponse_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* OSDHealthResult_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_xtreemfs_2fOSD_2eproto() {
  protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "xtreemfs/OSD.proto");
  GOOGLE_CHECK(file != NULL);
  InternalGmax_descriptor_ = file->message_type(0);
  static const int InternalGmax_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, epoch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, file_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, last_object_id_),
  };
  InternalGmax_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      InternalGmax_descriptor_,
      InternalGmax::default_instance_,
      InternalGmax_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalGmax, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(InternalGmax));
  Lock_descriptor_ = file->message_type(1);
  static const int Lock_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, client_pid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, client_uuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, offset_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, exclusive_),
  };
  Lock_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Lock_descriptor_,
      Lock::default_instance_,
      Lock_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Lock, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Lock));
  ObjectData_descriptor_ = file->message_type(2);
  static const int ObjectData_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, checksum_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, invalid_checksum_on_osd_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, zero_padding_),
  };
  ObjectData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ObjectData_descriptor_,
      ObjectData::default_instance_,
      ObjectData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ObjectData));
  ObjectList_descriptor_ = file->message_type(3);
  static const int ObjectList_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, set_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, stripe_width_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, first__),
  };
  ObjectList_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ObjectList_descriptor_,
      ObjectList::default_instance_,
      ObjectList_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectList, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ObjectList));
  ObjectVersion_descriptor_ = file->message_type(4);
  static const int ObjectVersion_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, object_version_),
  };
  ObjectVersion_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ObjectVersion_descriptor_,
      ObjectVersion::default_instance_,
      ObjectVersion_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersion, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ObjectVersion));
  TruncateRecord_descriptor_ = file->message_type(5);
  static const int TruncateRecord_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, last_object_number_),
  };
  TruncateRecord_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      TruncateRecord_descriptor_,
      TruncateRecord::default_instance_,
      TruncateRecord_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateRecord, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(TruncateRecord));
  TruncateLog_descriptor_ = file->message_type(6);
  static const int TruncateLog_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, records_),
  };
  TruncateLog_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      TruncateLog_descriptor_,
      TruncateLog::default_instance_,
      TruncateLog_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateLog, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(TruncateLog));
  XLocSetVersionState_descriptor_ = file->message_type(7);
  static const int XLocSetVersionState_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, invalidated_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, modified_time_),
  };
  XLocSetVersionState_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      XLocSetVersionState_descriptor_,
      XLocSetVersionState::default_instance_,
      XLocSetVersionState_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(XLocSetVersionState, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(XLocSetVersionState));
  ReplicaStatus_descriptor_ = file->message_type(8);
  static const int ReplicaStatus_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, truncate_epoch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, file_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, max_obj_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, primary_epoch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, objectversions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, truncate_log_),
  };
  ReplicaStatus_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ReplicaStatus_descriptor_,
      ReplicaStatus::default_instance_,
      ReplicaStatus_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicaStatus, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ReplicaStatus));
  ObjectVersionMapping_descriptor_ = file->message_type(9);
  static const int ObjectVersionMapping_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, object_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, osd_uuids_),
  };
  ObjectVersionMapping_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ObjectVersionMapping_descriptor_,
      ObjectVersionMapping::default_instance_,
      ObjectVersionMapping_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectVersionMapping, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ObjectVersionMapping));
  AuthoritativeReplicaState_descriptor_ = file->message_type(10);
  static const int AuthoritativeReplicaState_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, truncate_epoch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, max_obj_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, objectversions_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, truncate_log_),
  };
  AuthoritativeReplicaState_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      AuthoritativeReplicaState_descriptor_,
      AuthoritativeReplicaState::default_instance_,
      AuthoritativeReplicaState_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthoritativeReplicaState, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(AuthoritativeReplicaState));
  InternalReadLocalResponse_descriptor_ = file->message_type(11);
  static const int InternalReadLocalResponse_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, object_set_),
  };
  InternalReadLocalResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      InternalReadLocalResponse_descriptor_,
      InternalReadLocalResponse::default_instance_,
      InternalReadLocalResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InternalReadLocalResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(InternalReadLocalResponse));
  readRequest_descriptor_ = file->message_type(12);
  static const int readRequest_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, object_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, offset_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, length_),
  };
  readRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      readRequest_descriptor_,
      readRequest::default_instance_,
      readRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(readRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(readRequest));
  truncateRequest_descriptor_ = file->message_type(13);
  static const int truncateRequest_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, new_file_size_),
  };
  truncateRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      truncateRequest_descriptor_,
      truncateRequest::default_instance_,
      truncateRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(truncateRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(truncateRequest));
  unlink_osd_Request_descriptor_ = file->message_type(14);
  static const int unlink_osd_Request_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, file_id_),
  };
  unlink_osd_Request_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      unlink_osd_Request_descriptor_,
      unlink_osd_Request::default_instance_,
      unlink_osd_Request_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(unlink_osd_Request, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(unlink_osd_Request));
  writeRequest_descriptor_ = file->message_type(15);
  static const int writeRequest_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, offset_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, lease_timeout_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, object_data_),
  };
  writeRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      writeRequest_descriptor_,
      writeRequest::default_instance_,
      writeRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(writeRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(writeRequest));
  xtreemfs_broadcast_gmaxRequest_descriptor_ = file->message_type(16);
  static const int xtreemfs_broadcast_gmaxRequest_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, truncate_epoch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, last_object_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, file_size_),
  };
  xtreemfs_broadcast_gmaxRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_broadcast_gmaxRequest_descriptor_,
      xtreemfs_broadcast_gmaxRequest::default_instance_,
      xtreemfs_broadcast_gmaxRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_broadcast_gmaxRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_broadcast_gmaxRequest));
  xtreemfs_check_objectRequest_descriptor_ = file->message_type(17);
  static const int xtreemfs_check_objectRequest_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, object_version_),
  };
  xtreemfs_check_objectRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_check_objectRequest_descriptor_,
      xtreemfs_check_objectRequest::default_instance_,
      xtreemfs_check_objectRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_check_objectRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_check_objectRequest));
  xtreemfs_cleanup_get_resultsResponse_descriptor_ = file->message_type(18);
  static const int xtreemfs_cleanup_get_resultsResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, results_),
  };
  xtreemfs_cleanup_get_resultsResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_cleanup_get_resultsResponse_descriptor_,
      xtreemfs_cleanup_get_resultsResponse::default_instance_,
      xtreemfs_cleanup_get_resultsResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_get_resultsResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_cleanup_get_resultsResponse));
  xtreemfs_cleanup_is_runningResponse_descriptor_ = file->message_type(19);
  static const int xtreemfs_cleanup_is_runningResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, is_running_),
  };
  xtreemfs_cleanup_is_runningResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_cleanup_is_runningResponse_descriptor_,
      xtreemfs_cleanup_is_runningResponse::default_instance_,
      xtreemfs_cleanup_is_runningResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_is_runningResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_cleanup_is_runningResponse));
  xtreemfs_cleanup_startRequest_descriptor_ = file->message_type(20);
  static const int xtreemfs_cleanup_startRequest_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, remove_zombies_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, remove_unavail_volume_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, lost_and_found_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, delete_metadata_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, metadata_timeout_),
  };
  xtreemfs_cleanup_startRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_cleanup_startRequest_descriptor_,
      xtreemfs_cleanup_startRequest::default_instance_,
      xtreemfs_cleanup_startRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_startRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_cleanup_startRequest));
  xtreemfs_cleanup_statusResponse_descriptor_ = file->message_type(21);
  static const int xtreemfs_cleanup_statusResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, status_),
  };
  xtreemfs_cleanup_statusResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_cleanup_statusResponse_descriptor_,
      xtreemfs_cleanup_statusResponse::default_instance_,
      xtreemfs_cleanup_statusResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_cleanup_statusResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_cleanup_statusResponse));
  xtreemfs_rwr_fetchRequest_descriptor_ = file->message_type(22);
  static const int xtreemfs_rwr_fetchRequest_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, object_version_),
  };
  xtreemfs_rwr_fetchRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_fetchRequest_descriptor_,
      xtreemfs_rwr_fetchRequest::default_instance_,
      xtreemfs_rwr_fetchRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_fetchRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_fetchRequest));
  xtreemfs_repair_objectRequest_descriptor_ = file->message_type(23);
  static const int xtreemfs_repair_objectRequest_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, object_version_),
  };
  xtreemfs_repair_objectRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_repair_objectRequest_descriptor_,
      xtreemfs_repair_objectRequest::default_instance_,
      xtreemfs_repair_objectRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_repair_objectRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_repair_objectRequest));
  xtreemfs_rwr_flease_msgRequest_descriptor_ = file->message_type(24);
  static const int xtreemfs_rwr_flease_msgRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, sender_hostname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, sender_port_),
  };
  xtreemfs_rwr_flease_msgRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_flease_msgRequest_descriptor_,
      xtreemfs_rwr_flease_msgRequest::default_instance_,
      xtreemfs_rwr_flease_msgRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_flease_msgRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_flease_msgRequest));
  xtreemfs_rwr_set_primary_epochRequest_descriptor_ = file->message_type(25);
  static const int xtreemfs_rwr_set_primary_epochRequest_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, primary_epoch_),
  };
  xtreemfs_rwr_set_primary_epochRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_set_primary_epochRequest_descriptor_,
      xtreemfs_rwr_set_primary_epochRequest::default_instance_,
      xtreemfs_rwr_set_primary_epochRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_set_primary_epochRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_set_primary_epochRequest));
  xtreemfs_rwr_statusRequest_descriptor_ = file->message_type(26);
  static const int xtreemfs_rwr_statusRequest_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, max_local_obj_version_),
  };
  xtreemfs_rwr_statusRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_statusRequest_descriptor_,
      xtreemfs_rwr_statusRequest::default_instance_,
      xtreemfs_rwr_statusRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_statusRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_statusRequest));
  xtreemfs_rwr_truncateRequest_descriptor_ = file->message_type(27);
  static const int xtreemfs_rwr_truncateRequest_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, new_file_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, object_version_),
  };
  xtreemfs_rwr_truncateRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_truncateRequest_descriptor_,
      xtreemfs_rwr_truncateRequest::default_instance_,
      xtreemfs_rwr_truncateRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_truncateRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_truncateRequest));
  xtreemfs_rwr_updateRequest_descriptor_ = file->message_type(28);
  static const int xtreemfs_rwr_updateRequest_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, new_file_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, object_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, offset_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, obj_),
  };
  xtreemfs_rwr_updateRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_updateRequest_descriptor_,
      xtreemfs_rwr_updateRequest::default_instance_,
      xtreemfs_rwr_updateRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_updateRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_updateRequest));
  xtreemfs_internal_get_gmaxRequest_descriptor_ = file->message_type(29);
  static const int xtreemfs_internal_get_gmaxRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, file_id_),
  };
  xtreemfs_internal_get_gmaxRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_get_gmaxRequest_descriptor_,
      xtreemfs_internal_get_gmaxRequest::default_instance_,
      xtreemfs_internal_get_gmaxRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_gmaxRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_get_gmaxRequest));
  xtreemfs_internal_get_file_sizeRequest_descriptor_ = file->message_type(30);
  static const int xtreemfs_internal_get_file_sizeRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, file_id_),
  };
  xtreemfs_internal_get_file_sizeRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_get_file_sizeRequest_descriptor_,
      xtreemfs_internal_get_file_sizeRequest::default_instance_,
      xtreemfs_internal_get_file_sizeRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_get_file_sizeRequest));
  xtreemfs_internal_get_file_sizeResponse_descriptor_ = file->message_type(31);
  static const int xtreemfs_internal_get_file_sizeResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, file_size_),
  };
  xtreemfs_internal_get_file_sizeResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_get_file_sizeResponse_descriptor_,
      xtreemfs_internal_get_file_sizeResponse::default_instance_,
      xtreemfs_internal_get_file_sizeResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_file_sizeResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_get_file_sizeResponse));
  xtreemfs_internal_read_localRequest_descriptor_ = file->message_type(32);
  static const int xtreemfs_internal_read_localRequest_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, object_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, object_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, offset_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, attach_object_list_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, required_objects_),
  };
  xtreemfs_internal_read_localRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_read_localRequest_descriptor_,
      xtreemfs_internal_read_localRequest::default_instance_,
      xtreemfs_internal_read_localRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_read_localRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_read_localRequest));
  xtreemfs_internal_get_object_setRequest_descriptor_ = file->message_type(33);
  static const int xtreemfs_internal_get_object_setRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, file_id_),
  };
  xtreemfs_internal_get_object_setRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_get_object_setRequest_descriptor_,
      xtreemfs_internal_get_object_setRequest::default_instance_,
      xtreemfs_internal_get_object_setRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_object_setRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_get_object_setRequest));
  xtreemfs_internal_get_fileid_listResponse_descriptor_ = file->message_type(34);
  static const int xtreemfs_internal_get_fileid_listResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, file_ids_),
  };
  xtreemfs_internal_get_fileid_listResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_internal_get_fileid_listResponse_descriptor_,
      xtreemfs_internal_get_fileid_listResponse::default_instance_,
      xtreemfs_internal_get_fileid_listResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_internal_get_fileid_listResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_internal_get_fileid_listResponse));
  lockRequest_descriptor_ = file->message_type(35);
  static const int lockRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, lock_request_),
  };
  lockRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      lockRequest_descriptor_,
      lockRequest::default_instance_,
      lockRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(lockRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(lockRequest));
  xtreemfs_pingMesssage_descriptor_ = file->message_type(36);
  static const int xtreemfs_pingMesssage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, coordinates_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, request_response_),
  };
  xtreemfs_pingMesssage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_pingMesssage_descriptor_,
      xtreemfs_pingMesssage::default_instance_,
      xtreemfs_pingMesssage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_pingMesssage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_pingMesssage));
  xtreemfs_rwr_auth_stateRequest_descriptor_ = file->message_type(37);
  static const int xtreemfs_rwr_auth_stateRequest_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, state_),
  };
  xtreemfs_rwr_auth_stateRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_auth_stateRequest_descriptor_,
      xtreemfs_rwr_auth_stateRequest::default_instance_,
      xtreemfs_rwr_auth_stateRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_auth_stateRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_auth_stateRequest));
  xtreemfs_rwr_reset_completeRequest_descriptor_ = file->message_type(38);
  static const int xtreemfs_rwr_reset_completeRequest_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, primary_epoch_),
  };
  xtreemfs_rwr_reset_completeRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_rwr_reset_completeRequest_descriptor_,
      xtreemfs_rwr_reset_completeRequest::default_instance_,
      xtreemfs_rwr_reset_completeRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_rwr_reset_completeRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_rwr_reset_completeRequest));
  xtreemfs_xloc_set_invalidateRequest_descriptor_ = file->message_type(39);
  static const int xtreemfs_xloc_set_invalidateRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, file_credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, file_id_),
  };
  xtreemfs_xloc_set_invalidateRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_xloc_set_invalidateRequest_descriptor_,
      xtreemfs_xloc_set_invalidateRequest::default_instance_,
      xtreemfs_xloc_set_invalidateRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_xloc_set_invalidateRequest));
  xtreemfs_xloc_set_invalidateResponse_descriptor_ = file->message_type(40);
  static const int xtreemfs_xloc_set_invalidateResponse_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, lease_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, replica_status_),
  };
  xtreemfs_xloc_set_invalidateResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      xtreemfs_xloc_set_invalidateResponse_descriptor_,
      xtreemfs_xloc_set_invalidateResponse::default_instance_,
      xtreemfs_xloc_set_invalidateResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(xtreemfs_xloc_set_invalidateResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(xtreemfs_xloc_set_invalidateResponse));
  OSDHealthResult_descriptor_ = file->enum_type(0);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    InternalGmax_descriptor_, &InternalGmax::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Lock_descriptor_, &Lock::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ObjectData_descriptor_, &ObjectData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ObjectList_descriptor_, &ObjectList::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ObjectVersion_descriptor_, &ObjectVersion::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    TruncateRecord_descriptor_, &TruncateRecord::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    TruncateLog_descriptor_, &TruncateLog::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    XLocSetVersionState_descriptor_, &XLocSetVersionState::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ReplicaStatus_descriptor_, &ReplicaStatus::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ObjectVersionMapping_descriptor_, &ObjectVersionMapping::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    AuthoritativeReplicaState_descriptor_, &AuthoritativeReplicaState::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    InternalReadLocalResponse_descriptor_, &InternalReadLocalResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    readRequest_descriptor_, &readRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    truncateRequest_descriptor_, &truncateRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    unlink_osd_Request_descriptor_, &unlink_osd_Request::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    writeRequest_descriptor_, &writeRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_broadcast_gmaxRequest_descriptor_, &xtreemfs_broadcast_gmaxRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_check_objectRequest_descriptor_, &xtreemfs_check_objectRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_cleanup_get_resultsResponse_descriptor_, &xtreemfs_cleanup_get_resultsResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_cleanup_is_runningResponse_descriptor_, &xtreemfs_cleanup_is_runningResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_cleanup_startRequest_descriptor_, &xtreemfs_cleanup_startRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_cleanup_statusResponse_descriptor_, &xtreemfs_cleanup_statusResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_fetchRequest_descriptor_, &xtreemfs_rwr_fetchRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_repair_objectRequest_descriptor_, &xtreemfs_repair_objectRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_flease_msgRequest_descriptor_, &xtreemfs_rwr_flease_msgRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_set_primary_epochRequest_descriptor_, &xtreemfs_rwr_set_primary_epochRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_statusRequest_descriptor_, &xtreemfs_rwr_statusRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_truncateRequest_descriptor_, &xtreemfs_rwr_truncateRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_updateRequest_descriptor_, &xtreemfs_rwr_updateRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_get_gmaxRequest_descriptor_, &xtreemfs_internal_get_gmaxRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_get_file_sizeRequest_descriptor_, &xtreemfs_internal_get_file_sizeRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_get_file_sizeResponse_descriptor_, &xtreemfs_internal_get_file_sizeResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_read_localRequest_descriptor_, &xtreemfs_internal_read_localRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_get_object_setRequest_descriptor_, &xtreemfs_internal_get_object_setRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_internal_get_fileid_listResponse_descriptor_, &xtreemfs_internal_get_fileid_listResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    lockRequest_descriptor_, &lockRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_pingMesssage_descriptor_, &xtreemfs_pingMesssage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_auth_stateRequest_descriptor_, &xtreemfs_rwr_auth_stateRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_rwr_reset_completeRequest_descriptor_, &xtreemfs_rwr_reset_completeRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_xloc_set_invalidateRequest_descriptor_, &xtreemfs_xloc_set_invalidateRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    xtreemfs_xloc_set_invalidateResponse_descriptor_, &xtreemfs_xloc_set_invalidateResponse::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto() {
  delete InternalGmax::default_instance_;
  delete InternalGmax_reflection_;
  delete Lock::default_instance_;
  delete Lock_reflection_;
  delete ObjectData::default_instance_;
  delete ObjectData_reflection_;
  delete ObjectList::default_instance_;
  delete ObjectList_reflection_;
  delete ObjectVersion::default_instance_;
  delete ObjectVersion_reflection_;
  delete TruncateRecord::default_instance_;
  delete TruncateRecord_reflection_;
  delete TruncateLog::default_instance_;
  delete TruncateLog_reflection_;
  delete XLocSetVersionState::default_instance_;
  delete XLocSetVersionState_reflection_;
  delete ReplicaStatus::default_instance_;
  delete ReplicaStatus_reflection_;
  delete ObjectVersionMapping::default_instance_;
  delete ObjectVersionMapping_reflection_;
  delete AuthoritativeReplicaState::default_instance_;
  delete AuthoritativeReplicaState_reflection_;
  delete InternalReadLocalResponse::default_instance_;
  delete InternalReadLocalResponse_reflection_;
  delete readRequest::default_instance_;
  delete readRequest_reflection_;
  delete truncateRequest::default_instance_;
  delete truncateRequest_reflection_;
  delete unlink_osd_Request::default_instance_;
  delete unlink_osd_Request_reflection_;
  delete writeRequest::default_instance_;
  delete writeRequest_reflection_;
  delete xtreemfs_broadcast_gmaxRequest::default_instance_;
  delete xtreemfs_broadcast_gmaxRequest_reflection_;
  delete xtreemfs_check_objectRequest::default_instance_;
  delete xtreemfs_check_objectRequest_reflection_;
  delete xtreemfs_cleanup_get_resultsResponse::default_instance_;
  delete xtreemfs_cleanup_get_resultsResponse_reflection_;
  delete xtreemfs_cleanup_is_runningResponse::default_instance_;
  delete xtreemfs_cleanup_is_runningResponse_reflection_;
  delete xtreemfs_cleanup_startRequest::default_instance_;
  delete xtreemfs_cleanup_startRequest_reflection_;
  delete xtreemfs_cleanup_statusResponse::default_instance_;
  delete xtreemfs_cleanup_statusResponse_reflection_;
  delete xtreemfs_rwr_fetchRequest::default_instance_;
  delete xtreemfs_rwr_fetchRequest_reflection_;
  delete xtreemfs_repair_objectRequest::default_instance_;
  delete xtreemfs_repair_objectRequest_reflection_;
  delete xtreemfs_rwr_flease_msgRequest::default_instance_;
  delete xtreemfs_rwr_flease_msgRequest_reflection_;
  delete xtreemfs_rwr_set_primary_epochRequest::default_instance_;
  delete xtreemfs_rwr_set_primary_epochRequest_reflection_;
  delete xtreemfs_rwr_statusRequest::default_instance_;
  delete xtreemfs_rwr_statusRequest_reflection_;
  delete xtreemfs_rwr_truncateRequest::default_instance_;
  delete xtreemfs_rwr_truncateRequest_reflection_;
  delete xtreemfs_rwr_updateRequest::default_instance_;
  delete xtreemfs_rwr_updateRequest_reflection_;
  delete xtreemfs_internal_get_gmaxRequest::default_instance_;
  delete xtreemfs_internal_get_gmaxRequest_reflection_;
  delete xtreemfs_internal_get_file_sizeRequest::default_instance_;
  delete xtreemfs_internal_get_file_sizeRequest_reflection_;
  delete xtreemfs_internal_get_file_sizeResponse::default_instance_;
  delete xtreemfs_internal_get_file_sizeResponse_reflection_;
  delete xtreemfs_internal_read_localRequest::default_instance_;
  delete xtreemfs_internal_read_localRequest_reflection_;
  delete xtreemfs_internal_get_object_setRequest::default_instance_;
  delete xtreemfs_internal_get_object_setRequest_reflection_;
  delete xtreemfs_internal_get_fileid_listResponse::default_instance_;
  delete xtreemfs_internal_get_fileid_listResponse_reflection_;
  delete lockRequest::default_instance_;
  delete lockRequest_reflection_;
  delete xtreemfs_pingMesssage::default_instance_;
  delete xtreemfs_pingMesssage_reflection_;
  delete xtreemfs_rwr_auth_stateRequest::default_instance_;
  delete xtreemfs_rwr_auth_stateRequest_reflection_;
  delete xtreemfs_rwr_reset_completeRequest::default_instance_;
  delete xtreemfs_rwr_reset_completeRequest_reflection_;
  delete xtreemfs_xloc_set_invalidateRequest::default_instance_;
  delete xtreemfs_xloc_set_invalidateRequest_reflection_;
  delete xtreemfs_xloc_set_invalidateResponse::default_instance_;
  delete xtreemfs_xloc_set_invalidateResponse_reflection_;
}

void protobuf_AddDesc_xtreemfs_2fOSD_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/OSD.proto\022\016xtreemfs.pbrpc\032\023in"
    "clude/PBRPC.proto\032\024include/Common.proto\032"
    "\032xtreemfs/GlobalTypes.proto\"H\n\014InternalG"
    "max\022\r\n\005epoch\030\001 \002(\006\022\021\n\tfile_size\030\002 \002(\006\022\026\n"
    "\016last_object_id\030\003 \002(\006\"b\n\004Lock\022\022\n\nclient_"
    "pid\030\001 \002(\007\022\023\n\013client_uuid\030\002 \002(\t\022\016\n\006length"
    "\030\003 \002(\006\022\016\n\006offset\030\004 \002(\006\022\021\n\texclusive\030\005 \002("
    "\010\"U\n\nObjectData\022\020\n\010checksum\030\001 \002(\007\022\037\n\027inv"
    "alid_checksum_on_osd\030\002 \002(\010\022\024\n\014zero_paddi"
    "ng\030\003 \002(\007\"\?\n\nObjectList\022\013\n\003set\030\001 \002(\014\022\024\n\014s"
    "tripe_width\030\002 \002(\007\022\016\n\006first_\030\003 \002(\007\">\n\rObj"
    "ectVersion\022\025\n\robject_number\030\001 \002(\006\022\026\n\016obj"
    "ect_version\030\002 \002(\006\"=\n\016TruncateRecord\022\017\n\007v"
    "ersion\030\001 \002(\006\022\032\n\022last_object_number\030\002 \002(\006"
    "\">\n\013TruncateLog\022/\n\007records\030\001 \003(\0132\036.xtree"
    "mfs.pbrpc.TruncateRecord\"R\n\023XLocSetVersi"
    "onState\022\017\n\007version\030\001 \002(\007\022\023\n\013invalidated\030"
    "\002 \002(\010\022\025\n\rmodified_time\030\003 \001(\006\"\324\001\n\rReplica"
    "Status\022\026\n\016truncate_epoch\030\001 \002(\006\022\021\n\tfile_s"
    "ize\030\002 \002(\006\022\027\n\017max_obj_version\030\003 \002(\006\022\025\n\rpr"
    "imary_epoch\030\004 \002(\007\0225\n\016objectVersions\030\005 \003("
    "\0132\035.xtreemfs.pbrpc.ObjectVersion\0221\n\014trun"
    "cate_log\030\006 \002(\0132\033.xtreemfs.pbrpc.Truncate"
    "Log\"X\n\024ObjectVersionMapping\022\025\n\robject_nu"
    "mber\030\001 \002(\006\022\026\n\016object_version\030\002 \002(\006\022\021\n\tos"
    "d_uuids\030\003 \003(\t\"\275\001\n\031AuthoritativeReplicaSt"
    "ate\022\026\n\016truncate_epoch\030\001 \002(\006\022\027\n\017max_obj_v"
    "ersion\030\004 \002(\006\022<\n\016objectVersions\030\002 \003(\0132$.x"
    "treemfs.pbrpc.ObjectVersionMapping\0221\n\014tr"
    "uncate_log\030\003 \002(\0132\033.xtreemfs.pbrpc.Trunca"
    "teLog\"u\n\031InternalReadLocalResponse\022(\n\004da"
    "ta\030\001 \002(\0132\032.xtreemfs.pbrpc.ObjectData\022.\n\n"
    "object_set\030\002 \003(\0132\032.xtreemfs.pbrpc.Object"
    "List\"\250\001\n\013readRequest\0229\n\020file_credentials"
    "\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCredentials\022"
    "\017\n\007file_id\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022"
    "\026\n\016object_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022"
    "\016\n\006length\030\006 \002(\007\"t\n\017truncateRequest\0229\n\020fi"
    "le_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.Fi"
    "leCredentials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rnew_fi"
    "le_size\030\003 \002(\006\"`\n\022unlink_osd_Request\0229\n\020f"
    "ile_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.F"
    "ileCredentials\022\017\n\007file_id\030\002 \002(\t\"\341\001\n\014writ"
    "eRequest\0229\n\020file_credentials\030\001 \002(\0132\037.xtr"
    "eemfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002"
    " \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ve"
    "rsion\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022\025\n\rlease_tim"
    "eout\030\006 \002(\006\022/\n\013object_data\030\007 \002(\0132\032.xtreem"
    "fs.pbrpc.ObjectData\"q\n\036xtreemfs_broadcas"
    "t_gmaxRequest\022\017\n\007file_id\030\001 \002(\t\022\026\n\016trunca"
    "te_epoch\030\002 \002(\006\022\023\n\013last_object\030\003 \002(\006\022\021\n\tf"
    "ile_size\030\004 \002(\006\"\231\001\n\034xtreemfs_check_object"
    "Request\0229\n\020file_credentials\030\001 \002(\0132\037.xtre"
    "emfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002 "
    "\002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ver"
    "sion\030\004 \002(\006\"7\n$xtreemfs_cleanup_get_resul"
    "tsResponse\022\017\n\007results\030\001 \003(\t\"9\n#xtreemfs_"
    "cleanup_is_runningResponse\022\022\n\nis_running"
    "\030\001 \002(\010\"\241\001\n\035xtreemfs_cleanup_startRequest"
    "\022\026\n\016remove_zombies\030\001 \002(\010\022\035\n\025remove_unava"
    "il_volume\030\002 \002(\010\022\026\n\016lost_and_found\030\003 \002(\010\022"
    "\027\n\017delete_metadata\030\004 \002(\010\022\030\n\020metadata_tim"
    "eout\030\005 \002(\007\"1\n\037xtreemfs_cleanup_statusRes"
    "ponse\022\016\n\006status\030\001 \002(\t\"\226\001\n\031xtreemfs_rwr_f"
    "etchRequest\0229\n\020file_credentials\030\001 \002(\0132\037."
    "xtreemfs.pbrpc.FileCredentials\022\017\n\007file_i"
    "d\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object"
    "_version\030\004 \002(\006\"\232\001\n\035xtreemfs_repair_objec"
    "tRequest\0229\n\020file_credentials\030\001 \002(\0132\037.xtr"
    "eemfs.pbrpc.FileCredentials\022\017\n\007file_id\030\002"
    " \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016object_ve"
    "rsion\030\004 \002(\006\"N\n\036xtreemfs_rwr_flease_msgRe"
    "quest\022\027\n\017sender_hostname\030\001 \002(\t\022\023\n\013sender"
    "_port\030\002 \002(\007\"\212\001\n%xtreemfs_rwr_set_primary"
    "_epochRequest\0229\n\020file_credentials\030\001 \002(\0132"
    "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file"
    "_id\030\002 \002(\t\022\025\n\rprimary_epoch\030\003 \002(\007\"\207\001\n\032xtr"
    "eemfs_rwr_statusRequest\0229\n\020file_credenti"
    "als\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCredentia"
    "ls\022\017\n\007file_id\030\002 \002(\t\022\035\n\025max_local_obj_ver"
    "sion\030\003 \002(\006\"\231\001\n\034xtreemfs_rwr_truncateRequ"
    "est\0229\n\020file_credentials\030\001 \002(\0132\037.xtreemfs"
    ".pbrpc.FileCredentials\022\017\n\007file_id\030\002 \002(\t\022"
    "\025\n\rnew_file_size\030\003 \002(\006\022\026\n\016object_version"
    "\030\004 \002(\006\"\347\001\n\032xtreemfs_rwr_updateRequest\0229\n"
    "\020file_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc"
    ".FileCredentials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rnew"
    "_file_size\030\003 \002(\006\022\025\n\robject_number\030\007 \002(\006\022"
    "\026\n\016object_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022"
    "\'\n\003obj\030\006 \002(\0132\032.xtreemfs.pbrpc.ObjectData"
    "\"o\n!xtreemfs_internal_get_gmaxRequest\0229\n"
    "\020file_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc"
    ".FileCredentials\022\017\n\007file_id\030\002 \002(\t\"t\n&xtr"
    "eemfs_internal_get_file_sizeRequest\0229\n\020f"
    "ile_credentials\030\001 \002(\0132\037.xtreemfs.pbrpc.F"
    "ileCredentials\022\017\n\007file_id\030\002 \002(\t\"<\n\'xtree"
    "mfs_internal_get_file_sizeResponse\022\021\n\tfi"
    "le_size\030\001 \002(\006\"\222\002\n#xtreemfs_internal_read"
    "_localRequest\0229\n\020file_credentials\030\001 \002(\0132"
    "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file"
    "_id\030\002 \002(\t\022\025\n\robject_number\030\003 \002(\006\022\026\n\016obje"
    "ct_version\030\004 \002(\006\022\016\n\006offset\030\005 \002(\007\022\016\n\006leng"
    "th\030\006 \002(\007\022\032\n\022attach_object_list\030\007 \002(\010\0224\n\020"
    "required_objects\030\010 \003(\0132\032.xtreemfs.pbrpc."
    "ObjectList\"u\n\'xtreemfs_internal_get_obje"
    "ct_setRequest\0229\n\020file_credentials\030\001 \002(\0132"
    "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file"
    "_id\030\002 \002(\t\"=\n)xtreemfs_internal_get_filei"
    "d_listResponse\022\020\n\010file_ids\030\001 \003(\t\"t\n\013lock"
    "Request\0229\n\020file_credentials\030\001 \002(\0132\037.xtre"
    "emfs.pbrpc.FileCredentials\022*\n\014lock_reque"
    "st\030\002 \002(\0132\024.xtreemfs.pbrpc.Lock\"j\n\025xtreem"
    "fs_pingMesssage\0227\n\013coordinates\030\001 \002(\0132\".x"
    "treemfs.pbrpc.VivaldiCoordinates\022\030\n\020requ"
    "est_response\030\002 \002(\010\"\246\001\n\036xtreemfs_rwr_auth"
    "_stateRequest\0229\n\020file_credentials\030\001 \002(\0132"
    "\037.xtreemfs.pbrpc.FileCredentials\022\017\n\007file"
    "_id\030\002 \002(\t\0228\n\005state\030\003 \002(\0132).xtreemfs.pbrp"
    "c.AuthoritativeReplicaState\"\207\001\n\"xtreemfs"
    "_rwr_reset_completeRequest\0229\n\020file_crede"
    "ntials\030\001 \002(\0132\037.xtreemfs.pbrpc.FileCreden"
    "tials\022\017\n\007file_id\030\002 \002(\t\022\025\n\rprimary_epoch\030"
    "\003 \002(\007\"q\n#xtreemfs_xloc_set_invalidateReq"
    "uest\0229\n\020file_credentials\030\001 \002(\0132\037.xtreemf"
    "s.pbrpc.FileCredentials\022\017\n\007file_id\030\002 \002(\t"
    "\"\216\001\n$xtreemfs_xloc_set_invalidateRespons"
    "e\022/\n\013lease_state\030\001 \002(\0162\032.xtreemfs.pbrpc."
    "LeaseState\0225\n\016replica_status\030\002 \001(\0132\035.xtr"
    "eemfs.pbrpc.ReplicaStatus*\215\001\n\017OSDHealthR"
    "esult\022\034\n\030OSD_HEALTH_RESULT_PASSED\020\000\022\035\n\031O"
    "SD_HEALTH_RESULT_WARNING\020\001\022\034\n\030OSD_HEALTH"
    "_RESULT_FAILED\020\002\022\037\n\033OSD_HEALTH_RESULT_NO"
    "T_AVAIL\020\0032\277\036\n\nOSDService\022L\n\004read\022\033.xtree"
    "mfs.pbrpc.readRequest\032\032.xtreemfs.pbrpc.O"
    "bjectData\"\013\215\265\030\n\000\000\000\230\265\030\001\022V\n\010truncate\022\037.xtr"
    "eemfs.pbrpc.truncateRequest\032 .xtreemfs.p"
    "brpc.OSDWriteResponse\"\007\215\265\030\013\000\000\000\022T\n\006unlink"
    "\022\".xtreemfs.pbrpc.unlink_osd_Request\032\035.x"
    "treemfs.pbrpc.emptyResponse\"\007\215\265\030\014\000\000\000\022T\n\005"
    "write\022\034.xtreemfs.pbrpc.writeRequest\032 .xt"
    "reemfs.pbrpc.OSDWriteResponse\"\013\215\265\030\r\000\000\000\240\265"
    "\030\001\022q\n\027xtreemfs_broadcast_gmax\022..xtreemfs"
    ".pbrpc.xtreemfs_broadcast_gmaxRequest\032\035."
    "xtreemfs.pbrpc.emptyResponse\"\007\215\265\030\024\000\000\000\022j\n"
    "\025xtreemfs_check_object\022,.xtreemfs.pbrpc."
    "xtreemfs_check_objectRequest\032\032.xtreemfs."
    "pbrpc.ObjectData\"\007\215\265\030\025\000\000\000\022{\n\034xtreemfs_cl"
    "eanup_get_results\022\034.xtreemfs.pbrpc.empty"
    "Request\0324.xtreemfs.pbrpc.xtreemfs_cleanu"
    "p_get_resultsResponse\"\007\215\265\030\036\000\000\000\022y\n\033xtreem"
    "fs_cleanup_is_running\022\034.xtreemfs.pbrpc.e"
    "mptyRequest\0323.xtreemfs.pbrpc.xtreemfs_cl"
    "eanup_is_runningResponse\"\007\215\265\030\037\000\000\000\022o\n\026xtr"
    "eemfs_cleanup_start\022-.xtreemfs.pbrpc.xtr"
    "eemfs_cleanup_startRequest\032\035.xtreemfs.pb"
    "rpc.emptyResponse\"\007\215\265\030 \000\000\000\022q\n\027xtreemfs_c"
    "leanup_status\022\034.xtreemfs.pbrpc.emptyRequ"
    "est\032/.xtreemfs.pbrpc.xtreemfs_cleanup_st"
    "atusResponse\"\007\215\265\030!\000\000\000\022]\n\025xtreemfs_cleanu"
    "p_stop\022\034.xtreemfs.pbrpc.emptyRequest\032\035.x"
    "treemfs.pbrpc.emptyResponse\"\007\215\265\030\"\000\000\000\022g\n\037"
    "xtreemfs_cleanup_versions_start\022\034.xtreem"
    "fs.pbrpc.emptyRequest\032\035.xtreemfs.pbrpc.e"
    "mptyResponse\"\007\215\265\030#\000\000\000\022o\n\026xtreemfs_repair"
    "_object\022-.xtreemfs.pbrpc.xtreemfs_repair"
    "_objectRequest\032\035.xtreemfs.pbrpc.emptyRes"
    "ponse\"\007\215\265\030$\000\000\000\022d\n\022xtreemfs_rwr_fetch\022).x"
    "treemfs.pbrpc.xtreemfs_rwr_fetchRequest\032"
    "\032.xtreemfs.pbrpc.ObjectData\"\007\215\265\030I\000\000\000\022u\n\027"
    "xtreemfs_rwr_flease_msg\022..xtreemfs.pbrpc"
    ".xtreemfs_rwr_flease_msgRequest\032\035.xtreem"
    "fs.pbrpc.emptyResponse\"\013\215\265\030G\000\000\000\240\265\030\001\022^\n\023x"
    "treemfs_rwr_notify\022\037.xtreemfs.pbrpc.File"
    "Credentials\032\035.xtreemfs.pbrpc.emptyRespon"
    "se\"\007\215\265\030K\000\000\000\022|\n\036xtreemfs_rwr_set_primary_"
    "epoch\0225.xtreemfs.pbrpc.xtreemfs_rwr_set_"
    "primary_epochRequest\032\032.xtreemfs.pbrpc.Ob"
    "jectData\"\007\215\265\030N\000\000\000\022i\n\023xtreemfs_rwr_status"
    "\022*.xtreemfs.pbrpc.xtreemfs_rwr_statusReq"
    "uest\032\035.xtreemfs.pbrpc.ReplicaStatus\"\007\215\265\030"
    "L\000\000\000\022m\n\025xtreemfs_rwr_truncate\022,.xtreemfs"
    ".pbrpc.xtreemfs_rwr_truncateRequest\032\035.xt"
    "reemfs.pbrpc.emptyResponse\"\007\215\265\030J\000\000\000\022m\n\023x"
    "treemfs_rwr_update\022*.xtreemfs.pbrpc.xtre"
    "emfs_rwr_updateRequest\032\035.xtreemfs.pbrpc."
    "emptyResponse\"\013\215\265\030H\000\000\000\240\265\030\001\022q\n\027xtreemfs_r"
    "wr_auth_state\022..xtreemfs.pbrpc.xtreemfs_"
    "rwr_auth_stateRequest\032\035.xtreemfs.pbrpc.e"
    "mptyResponse\"\007\215\265\030O\000\000\000\022y\n\033xtreemfs_rwr_re"
    "set_complete\0222.xtreemfs.pbrpc.xtreemfs_r"
    "wr_reset_completeRequest\032\035.xtreemfs.pbrp"
    "c.emptyResponse\"\007\215\265\030P\000\000\000\022v\n\032xtreemfs_int"
    "ernal_get_gmax\0221.xtreemfs.pbrpc.xtreemfs"
    "_internal_get_gmaxRequest\032\034.xtreemfs.pbr"
    "pc.InternalGmax\"\007\215\265\030(\000\000\000\022h\n\032xtreemfs_int"
    "ernal_truncate\022\037.xtreemfs.pbrpc.truncate"
    "Request\032 .xtreemfs.pbrpc.OSDWriteRespons"
    "e\"\007\215\265\030)\000\000\000\022\233\001\n\037xtreemfs_internal_get_fil"
    "e_size\0226.xtreemfs.pbrpc.xtreemfs_interna"
    "l_get_file_sizeRequest\0327.xtreemfs.pbrpc."
    "xtreemfs_internal_get_file_sizeResponse\""
    "\007\215\265\030*\000\000\000\022\207\001\n\034xtreemfs_internal_read_loca"
    "l\0223.xtreemfs.pbrpc.xtreemfs_internal_rea"
    "d_localRequest\032).xtreemfs.pbrpc.Internal"
    "ReadLocalResponse\"\007\215\265\030+\000\000\000\022\200\001\n xtreemfs_"
    "internal_get_object_set\0227.xtreemfs.pbrpc"
    ".xtreemfs_internal_get_object_setRequest"
    "\032\032.xtreemfs.pbrpc.ObjectList\"\007\215\265\030,\000\000\000\022\205\001"
    "\n!xtreemfs_internal_get_fileid_list\022\034.xt"
    "reemfs.pbrpc.emptyRequest\0329.xtreemfs.pbr"
    "pc.xtreemfs_internal_get_fileid_listResp"
    "onse\"\007\215\265\030-\000\000\000\022S\n\025xtreemfs_lock_acquire\022\033"
    ".xtreemfs.pbrpc.lockRequest\032\024.xtreemfs.p"
    "brpc.Lock\"\007\215\265\0302\000\000\000\022Q\n\023xtreemfs_lock_chec"
    "k\022\033.xtreemfs.pbrpc.lockRequest\032\024.xtreemf"
    "s.pbrpc.Lock\"\007\215\265\0303\000\000\000\022\\\n\025xtreemfs_lock_r"
    "elease\022\033.xtreemfs.pbrpc.lockRequest\032\035.xt"
    "reemfs.pbrpc.emptyResponse\"\007\215\265\0304\000\000\000\022f\n\rx"
    "treemfs_ping\022%.xtreemfs.pbrpc.xtreemfs_p"
    "ingMesssage\032%.xtreemfs.pbrpc.xtreemfs_pi"
    "ngMesssage\"\007\215\265\030<\000\000\000\022Y\n\021xtreemfs_shutdown"
    "\022\034.xtreemfs.pbrpc.emptyRequest\032\035.xtreemf"
    "s.pbrpc.emptyResponse\"\007\215\265\030F\000\000\000\022\222\001\n\034xtree"
    "mfs_xloc_set_invalidate\0223.xtreemfs.pbrpc"
    ".xtreemfs_xloc_set_invalidateRequest\0324.x"
    "treemfs.pbrpc.xtreemfs_xloc_set_invalida"
    "teResponse\"\007\215\265\030Q\000\000\000\022}\n#xtreemfs_rwr_auth"
    "_state_invalidated\022..xtreemfs.pbrpc.xtre"
    "emfs_rwr_auth_stateRequest\032\035.xtreemfs.pb"
    "rpc.emptyResponse\"\007\215\265\030R\000\000\000\032\007\225\265\0301u\000\000B(\n&o"
    "rg.xtreemfs.pbrpc.generatedinterfaces", 9237);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "xtreemfs/OSD.proto", &protobuf_RegisterTypes);
  InternalGmax::default_instance_ = new InternalGmax();
  Lock::default_instance_ = new Lock();
  ObjectData::default_instance_ = new ObjectData();
  ObjectList::default_instance_ = new ObjectList();
  ObjectVersion::default_instance_ = new ObjectVersion();
  TruncateRecord::default_instance_ = new TruncateRecord();
  TruncateLog::default_instance_ = new TruncateLog();
  XLocSetVersionState::default_instance_ = new XLocSetVersionState();
  ReplicaStatus::default_instance_ = new ReplicaStatus();
  ObjectVersionMapping::default_instance_ = new ObjectVersionMapping();
  AuthoritativeReplicaState::default_instance_ = new AuthoritativeReplicaState();
  InternalReadLocalResponse::default_instance_ = new InternalReadLocalResponse();
  readRequest::default_instance_ = new readRequest();
  truncateRequest::default_instance_ = new truncateRequest();
  unlink_osd_Request::default_instance_ = new unlink_osd_Request();
  writeRequest::default_instance_ = new writeRequest();
  xtreemfs_broadcast_gmaxRequest::default_instance_ = new xtreemfs_broadcast_gmaxRequest();
  xtreemfs_check_objectRequest::default_instance_ = new xtreemfs_check_objectRequest();
  xtreemfs_cleanup_get_resultsResponse::default_instance_ = new xtreemfs_cleanup_get_resultsResponse();
  xtreemfs_cleanup_is_runningResponse::default_instance_ = new xtreemfs_cleanup_is_runningResponse();
  xtreemfs_cleanup_startRequest::default_instance_ = new xtreemfs_cleanup_startRequest();
  xtreemfs_cleanup_statusResponse::default_instance_ = new xtreemfs_cleanup_statusResponse();
  xtreemfs_rwr_fetchRequest::default_instance_ = new xtreemfs_rwr_fetchRequest();
  xtreemfs_repair_objectRequest::default_instance_ = new xtreemfs_repair_objectRequest();
  xtreemfs_rwr_flease_msgRequest::default_instance_ = new xtreemfs_rwr_flease_msgRequest();
  xtreemfs_rwr_set_primary_epochRequest::default_instance_ = new xtreemfs_rwr_set_primary_epochRequest();
  xtreemfs_rwr_statusRequest::default_instance_ = new xtreemfs_rwr_statusRequest();
  xtreemfs_rwr_truncateRequest::default_instance_ = new xtreemfs_rwr_truncateRequest();
  xtreemfs_rwr_updateRequest::default_instance_ = new xtreemfs_rwr_updateRequest();
  xtreemfs_internal_get_gmaxRequest::default_instance_ = new xtreemfs_internal_get_gmaxRequest();
  xtreemfs_internal_get_file_sizeRequest::default_instance_ = new xtreemfs_internal_get_file_sizeRequest();
  xtreemfs_internal_get_file_sizeResponse::default_instance_ = new xtreemfs_internal_get_file_sizeResponse();
  xtreemfs_internal_read_localRequest::default_instance_ = new xtreemfs_internal_read_localRequest();
  xtreemfs_internal_get_object_setRequest::default_instance_ = new xtreemfs_internal_get_object_setRequest();
  xtreemfs_internal_get_fileid_listResponse::default_instance_ = new xtreemfs_internal_get_fileid_listResponse();
  lockRequest::default_instance_ = new lockRequest();
  xtreemfs_pingMesssage::default_instance_ = new xtreemfs_pingMesssage();
  xtreemfs_rwr_auth_stateRequest::default_instance_ = new xtreemfs_rwr_auth_stateRequest();
  xtreemfs_rwr_reset_completeRequest::default_instance_ = new xtreemfs_rwr_reset_completeRequest();
  xtreemfs_xloc_set_invalidateRequest::default_instance_ = new xtreemfs_xloc_set_invalidateRequest();
  xtreemfs_xloc_set_invalidateResponse::default_instance_ = new xtreemfs_xloc_set_invalidateResponse();
  InternalGmax::default_instance_->InitAsDefaultInstance();
  Lock::default_instance_->InitAsDefaultInstance();
  ObjectData::default_instance_->InitAsDefaultInstance();
  ObjectList::default_instance_->InitAsDefaultInstance();
  ObjectVersion::default_instance_->InitAsDefaultInstance();
  TruncateRecord::default_instance_->InitAsDefaultInstance();
  TruncateLog::default_instance_->InitAsDefaultInstance();
  XLocSetVersionState::default_instance_->InitAsDefaultInstance();
  ReplicaStatus::default_instance_->InitAsDefaultInstance();
  ObjectVersionMapping::default_instance_->InitAsDefaultInstance();
  AuthoritativeReplicaState::default_instance_->InitAsDefaultInstance();
  InternalReadLocalResponse::default_instance_->InitAsDefaultInstance();
  readRequest::default_instance_->InitAsDefaultInstance();
  truncateRequest::default_instance_->InitAsDefaultInstance();
  unlink_osd_Request::default_instance_->InitAsDefaultInstance();
  writeRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_broadcast_gmaxRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_check_objectRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_cleanup_get_resultsResponse::default_instance_->InitAsDefaultInstance();
  xtreemfs_cleanup_is_runningResponse::default_instance_->InitAsDefaultInstance();
  xtreemfs_cleanup_startRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_cleanup_statusResponse::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_fetchRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_repair_objectRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_flease_msgRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_set_primary_epochRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_statusRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_truncateRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_updateRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_get_gmaxRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_get_file_sizeRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_get_file_sizeResponse::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_read_localRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_get_object_setRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_internal_get_fileid_listResponse::default_instance_->InitAsDefaultInstance();
  lockRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_pingMesssage::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_auth_stateRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_rwr_reset_completeRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_xloc_set_invalidateRequest::default_instance_->InitAsDefaultInstance();
  xtreemfs_xloc_set_invalidateResponse::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fOSD_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_xtreemfs_2fOSD_2eproto {
  StaticDescriptorInitializer_xtreemfs_2fOSD_2eproto() {
    protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  }
} static_descriptor_initializer_xtreemfs_2fOSD_2eproto_;
const ::google::protobuf::EnumDescriptor* OSDHealthResult_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return OSDHealthResult_descriptor_;
}
bool OSDHealthResult_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int InternalGmax::kEpochFieldNumber;
const int InternalGmax::kFileSizeFieldNumber;
const int InternalGmax::kLastObjectIdFieldNumber;
#endif  // !_MSC_VER

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

void InternalGmax::InitAsDefaultInstance() {
}

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

void InternalGmax::SharedCtor() {
  _cached_size_ = 0;
  epoch_ = GOOGLE_ULONGLONG(0);
  file_size_ = GOOGLE_ULONGLONG(0);
  last_object_id_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const InternalGmax& InternalGmax::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

InternalGmax* InternalGmax::default_instance_ = NULL;

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

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

bool InternalGmax::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 epoch = 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, &epoch_)));
          set_has_epoch();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_file_size;
        break;
      }

      // required fixed64 file_size = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &file_size_)));
          set_has_file_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_last_object_id;
        break;
      }

      // required fixed64 last_object_id = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_last_object_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &last_object_id_)));
          set_has_last_object_id();
        } 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 InternalGmax::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 epoch = 1;
  if (has_epoch()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->epoch(), output);
  }

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

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

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

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

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

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

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

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

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

    // required fixed64 file_size = 2;
    if (has_file_size()) {
      total_size += 1 + 8;
    }

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

void InternalGmax::MergeFrom(const InternalGmax& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_epoch()) {
      set_epoch(from.epoch());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
    if (from.has_last_object_id()) {
      set_last_object_id(from.last_object_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void InternalGmax::Swap(InternalGmax* other) {
  if (other != this) {
    std::swap(epoch_, other->epoch_);
    std::swap(file_size_, other->file_size_);
    std::swap(last_object_id_, other->last_object_id_);
    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 InternalGmax::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = InternalGmax_descriptor_;
  metadata.reflection = InternalGmax_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Lock::kClientPidFieldNumber;
const int Lock::kClientUuidFieldNumber;
const int Lock::kLengthFieldNumber;
const int Lock::kOffsetFieldNumber;
const int Lock::kExclusiveFieldNumber;
#endif  // !_MSC_VER

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

void Lock::InitAsDefaultInstance() {
}

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

void Lock::SharedCtor() {
  _cached_size_ = 0;
  client_pid_ = 0u;
  client_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  length_ = GOOGLE_ULONGLONG(0);
  offset_ = GOOGLE_ULONGLONG(0);
  exclusive_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const Lock& Lock::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

Lock* Lock::default_instance_ = NULL;

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

void Lock::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    client_pid_ = 0u;
    if (has_client_uuid()) {
      if (client_uuid_ != &::google::protobuf::internal::kEmptyString) {
        client_uuid_->clear();
      }
    }
    length_ = GOOGLE_ULONGLONG(0);
    offset_ = GOOGLE_ULONGLONG(0);
    exclusive_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

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

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

      // required fixed64 length = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_offset;
        break;
      }

      // required fixed64 offset = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_exclusive;
        break;
      }

      // required bool exclusive = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_exclusive:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &exclusive_)));
          set_has_exclusive();
        } 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 Lock::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed32 client_pid = 1;
  if (has_client_pid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->client_pid(), output);
  }

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

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

  // required fixed64 offset = 4;
  if (has_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->offset(), output);
  }

  // required bool exclusive = 5;
  if (has_exclusive()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->exclusive(), output);
  }

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

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

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

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

  // required fixed64 offset = 4;
  if (has_offset()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->offset(), target);
  }

  // required bool exclusive = 5;
  if (has_exclusive()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->exclusive(), target);
  }

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

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

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

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

    // required fixed64 length = 3;
    if (has_length()) {
      total_size += 1 + 8;
    }

    // required fixed64 offset = 4;
    if (has_offset()) {
      total_size += 1 + 8;
    }

    // required bool exclusive = 5;
    if (has_exclusive()) {
      total_size += 1 + 1;
    }

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

void Lock::MergeFrom(const Lock& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_client_pid()) {
      set_client_pid(from.client_pid());
    }
    if (from.has_client_uuid()) {
      set_client_uuid(from.client_uuid());
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_exclusive()) {
      set_exclusive(from.exclusive());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void Lock::Swap(Lock* other) {
  if (other != this) {
    std::swap(client_pid_, other->client_pid_);
    std::swap(client_uuid_, other->client_uuid_);
    std::swap(length_, other->length_);
    std::swap(offset_, other->offset_);
    std::swap(exclusive_, other->exclusive_);
    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 Lock::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Lock_descriptor_;
  metadata.reflection = Lock_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ObjectData::kChecksumFieldNumber;
const int ObjectData::kInvalidChecksumOnOsdFieldNumber;
const int ObjectData::kZeroPaddingFieldNumber;
#endif  // !_MSC_VER

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

void ObjectData::InitAsDefaultInstance() {
}

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

void ObjectData::SharedCtor() {
  _cached_size_ = 0;
  checksum_ = 0u;
  invalid_checksum_on_osd_ = false;
  zero_padding_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const ObjectData& ObjectData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

ObjectData* ObjectData::default_instance_ = NULL;

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

void ObjectData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    checksum_ = 0u;
    invalid_checksum_on_osd_ = false;
    zero_padding_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

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

      // required bool invalid_checksum_on_osd = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_invalid_checksum_on_osd:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &invalid_checksum_on_osd_)));
          set_has_invalid_checksum_on_osd();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_zero_padding;
        break;
      }

      // required fixed32 zero_padding = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_zero_padding:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &zero_padding_)));
          set_has_zero_padding();
        } 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 ObjectData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed32 checksum = 1;
  if (has_checksum()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->checksum(), output);
  }

  // required bool invalid_checksum_on_osd = 2;
  if (has_invalid_checksum_on_osd()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->invalid_checksum_on_osd(), output);
  }

  // required fixed32 zero_padding = 3;
  if (has_zero_padding()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->zero_padding(), output);
  }

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

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

  // required bool invalid_checksum_on_osd = 2;
  if (has_invalid_checksum_on_osd()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->invalid_checksum_on_osd(), target);
  }

  // required fixed32 zero_padding = 3;
  if (has_zero_padding()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->zero_padding(), target);
  }

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

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

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

    // required bool invalid_checksum_on_osd = 2;
    if (has_invalid_checksum_on_osd()) {
      total_size += 1 + 1;
    }

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

void ObjectData::MergeFrom(const ObjectData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_checksum()) {
      set_checksum(from.checksum());
    }
    if (from.has_invalid_checksum_on_osd()) {
      set_invalid_checksum_on_osd(from.invalid_checksum_on_osd());
    }
    if (from.has_zero_padding()) {
      set_zero_padding(from.zero_padding());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void ObjectData::Swap(ObjectData* other) {
  if (other != this) {
    std::swap(checksum_, other->checksum_);
    std::swap(invalid_checksum_on_osd_, other->invalid_checksum_on_osd_);
    std::swap(zero_padding_, other->zero_padding_);
    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 ObjectData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ObjectData_descriptor_;
  metadata.reflection = ObjectData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ObjectList::kSetFieldNumber;
const int ObjectList::kStripeWidthFieldNumber;
const int ObjectList::kFirstFieldNumber;
#endif  // !_MSC_VER

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

void ObjectList::InitAsDefaultInstance() {
}

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

void ObjectList::SharedCtor() {
  _cached_size_ = 0;
  set_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  stripe_width_ = 0u;
  first__ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const ObjectList& ObjectList::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

ObjectList* ObjectList::default_instance_ = NULL;

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

void ObjectList::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_set()) {
      if (set_ != &::google::protobuf::internal::kEmptyString) {
        set_->clear();
      }
    }
    stripe_width_ = 0u;
    first__ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ObjectList::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 bytes set = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_set()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_stripe_width;
        break;
      }

      // required fixed32 stripe_width = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_stripe_width:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &stripe_width_)));
          set_has_stripe_width();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_first_;
        break;
      }

      // required fixed32 first_ = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_first_:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &first__)));
          set_has_first_();
        } 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 ObjectList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required bytes set = 1;
  if (has_set()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->set(), output);
  }

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

  // required fixed32 first_ = 3;
  if (has_first_()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->first_(), output);
  }

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

::google::protobuf::uint8* ObjectList::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required bytes set = 1;
  if (has_set()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->set(), target);
  }

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

  // required fixed32 first_ = 3;
  if (has_first_()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->first_(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes set = 1;
    if (has_set()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->set());
    }

    // required fixed32 stripe_width = 2;
    if (has_stripe_width()) {
      total_size += 1 + 4;
    }

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

void ObjectList::MergeFrom(const ObjectList& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_set()) {
      set_set(from.set());
    }
    if (from.has_stripe_width()) {
      set_stripe_width(from.stripe_width());
    }
    if (from.has_first_()) {
      set_first_(from.first_());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void ObjectList::Swap(ObjectList* other) {
  if (other != this) {
    std::swap(set_, other->set_);
    std::swap(stripe_width_, other->stripe_width_);
    std::swap(first__, other->first__);
    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 ObjectList::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ObjectList_descriptor_;
  metadata.reflection = ObjectList_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ObjectVersion::kObjectNumberFieldNumber;
const int ObjectVersion::kObjectVersionFieldNumber;
#endif  // !_MSC_VER

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

void ObjectVersion::InitAsDefaultInstance() {
}

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

void ObjectVersion::SharedCtor() {
  _cached_size_ = 0;
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const ObjectVersion& ObjectVersion::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

ObjectVersion* ObjectVersion::default_instance_ = NULL;

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

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

bool ObjectVersion::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 object_number = 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, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_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 ObjectVersion::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 object_number = 1;
  if (has_object_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->object_number(), output);
  }

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

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

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

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

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

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

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

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

void ObjectVersion::MergeFrom(const ObjectVersion& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void ObjectVersion::Swap(ObjectVersion* other) {
  if (other != this) {
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_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 ObjectVersion::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ObjectVersion_descriptor_;
  metadata.reflection = ObjectVersion_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int TruncateRecord::kVersionFieldNumber;
const int TruncateRecord::kLastObjectNumberFieldNumber;
#endif  // !_MSC_VER

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

void TruncateRecord::InitAsDefaultInstance() {
}

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

void TruncateRecord::SharedCtor() {
  _cached_size_ = 0;
  version_ = GOOGLE_ULONGLONG(0);
  last_object_number_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const TruncateRecord& TruncateRecord::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

TruncateRecord* TruncateRecord::default_instance_ = NULL;

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

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

bool TruncateRecord::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 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, &version_)));
          set_has_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_last_object_number;
        break;
      }

      // required fixed64 last_object_number = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_last_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &last_object_number_)));
          set_has_last_object_number();
        } 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 TruncateRecord::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 version = 1;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->version(), output);
  }

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

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

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

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

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

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

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

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

void TruncateRecord::MergeFrom(const TruncateRecord& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_last_object_number()) {
      set_last_object_number(from.last_object_number());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

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


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

#ifndef _MSC_VER
const int TruncateLog::kRecordsFieldNumber;
#endif  // !_MSC_VER

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

void TruncateLog::InitAsDefaultInstance() {
}

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

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

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

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

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

const TruncateLog& TruncateLog::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

TruncateLog* TruncateLog::default_instance_ = NULL;

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

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

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

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

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

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

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

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

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

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

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

bool TruncateLog::IsInitialized() const {

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

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


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

#ifndef _MSC_VER
const int XLocSetVersionState::kVersionFieldNumber;
const int XLocSetVersionState::kInvalidatedFieldNumber;
const int XLocSetVersionState::kModifiedTimeFieldNumber;
#endif  // !_MSC_VER

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

void XLocSetVersionState::InitAsDefaultInstance() {
}

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

void XLocSetVersionState::SharedCtor() {
  _cached_size_ = 0;
  version_ = 0u;
  invalidated_ = false;
  modified_time_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const XLocSetVersionState& XLocSetVersionState::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

XLocSetVersionState* XLocSetVersionState::default_instance_ = NULL;

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

void XLocSetVersionState::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    version_ = 0u;
    invalidated_ = false;
    modified_time_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

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

      // required bool invalidated = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_invalidated:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &invalidated_)));
          set_has_invalidated();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_modified_time;
        break;
      }

      // optional fixed64 modified_time = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_modified_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &modified_time_)));
          set_has_modified_time();
        } 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 XLocSetVersionState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed32 version = 1;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->version(), output);
  }

  // required bool invalidated = 2;
  if (has_invalidated()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->invalidated(), output);
  }

  // optional fixed64 modified_time = 3;
  if (has_modified_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->modified_time(), output);
  }

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

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

  // required bool invalidated = 2;
  if (has_invalidated()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->invalidated(), target);
  }

  // optional fixed64 modified_time = 3;
  if (has_modified_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->modified_time(), target);
  }

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

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

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

    // required bool invalidated = 2;
    if (has_invalidated()) {
      total_size += 1 + 1;
    }

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

void XLocSetVersionState::MergeFrom(const XLocSetVersionState& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_invalidated()) {
      set_invalidated(from.invalidated());
    }
    if (from.has_modified_time()) {
      set_modified_time(from.modified_time());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void XLocSetVersionState::Swap(XLocSetVersionState* other) {
  if (other != this) {
    std::swap(version_, other->version_);
    std::swap(invalidated_, other->invalidated_);
    std::swap(modified_time_, other->modified_time_);
    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 XLocSetVersionState::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = XLocSetVersionState_descriptor_;
  metadata.reflection = XLocSetVersionState_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ReplicaStatus::kTruncateEpochFieldNumber;
const int ReplicaStatus::kFileSizeFieldNumber;
const int ReplicaStatus::kMaxObjVersionFieldNumber;
const int ReplicaStatus::kPrimaryEpochFieldNumber;
const int ReplicaStatus::kObjectVersionsFieldNumber;
const int ReplicaStatus::kTruncateLogFieldNumber;
#endif  // !_MSC_VER

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

void ReplicaStatus::InitAsDefaultInstance() {
  truncate_log_ = const_cast< ::xtreemfs::pbrpc::TruncateLog*>(&::xtreemfs::pbrpc::TruncateLog::default_instance());
}

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

void ReplicaStatus::SharedCtor() {
  _cached_size_ = 0;
  truncate_epoch_ = GOOGLE_ULONGLONG(0);
  file_size_ = GOOGLE_ULONGLONG(0);
  max_obj_version_ = GOOGLE_ULONGLONG(0);
  primary_epoch_ = 0u;
  truncate_log_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void ReplicaStatus::SharedDtor() {
  if (this != default_instance_) {
    delete truncate_log_;
  }
}

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

const ReplicaStatus& ReplicaStatus::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

ReplicaStatus* ReplicaStatus::default_instance_ = NULL;

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

void ReplicaStatus::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    truncate_epoch_ = GOOGLE_ULONGLONG(0);
    file_size_ = GOOGLE_ULONGLONG(0);
    max_obj_version_ = GOOGLE_ULONGLONG(0);
    primary_epoch_ = 0u;
    if (has_truncate_log()) {
      if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear();
    }
  }
  objectversions_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ReplicaStatus::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 truncate_epoch = 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, &truncate_epoch_)));
          set_has_truncate_epoch();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_file_size;
        break;
      }

      // required fixed64 file_size = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &file_size_)));
          set_has_file_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_max_obj_version;
        break;
      }

      // required fixed64 max_obj_version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_max_obj_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &max_obj_version_)));
          set_has_max_obj_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_primary_epoch;
        break;
      }

      // required fixed32 primary_epoch = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_primary_epoch:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &primary_epoch_)));
          set_has_primary_epoch();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_objectVersions;
        break;
      }

      // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_objectVersions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_objectversions()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_objectVersions;
        if (input->ExpectTag(50)) goto parse_truncate_log;
        break;
      }

      // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_truncate_log:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_truncate_log()));
        } 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 ReplicaStatus::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 truncate_epoch = 1;
  if (has_truncate_epoch()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->truncate_epoch(), output);
  }

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

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

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

  // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5;
  for (int i = 0; i < this->objectversions_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->objectversions(i), output);
  }

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

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

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

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

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

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

  // repeated .xtreemfs.pbrpc.ObjectVersion objectVersions = 5;
  for (int i = 0; i < this->objectversions_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->objectversions(i), target);
  }

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

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

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

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

    // required fixed64 file_size = 2;
    if (has_file_size()) {
      total_size += 1 + 8;
    }

    // required fixed64 max_obj_version = 3;
    if (has_max_obj_version()) {
      total_size += 1 + 8;
    }

    // required fixed32 primary_epoch = 4;
    if (has_primary_epoch()) {
      total_size += 1 + 4;
    }

    // required .xtreemfs.pbrpc.TruncateLog truncate_log = 6;
    if (has_truncate_log()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->truncate_log());
    }

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

void ReplicaStatus::MergeFrom(const ReplicaStatus& from) {
  GOOGLE_CHECK_NE(&from, this);
  objectversions_.MergeFrom(from.objectversions_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_truncate_epoch()) {
      set_truncate_epoch(from.truncate_epoch());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
    if (from.has_max_obj_version()) {
      set_max_obj_version(from.max_obj_version());
    }
    if (from.has_primary_epoch()) {
      set_primary_epoch(from.primary_epoch());
    }
    if (from.has_truncate_log()) {
      mutable_truncate_log()->::xtreemfs::pbrpc::TruncateLog::MergeFrom(from.truncate_log());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  for (int i = 0; i < objectversions_size(); i++) {
    if (!this->objectversions(i).IsInitialized()) return false;
  }
  if (has_truncate_log()) {
    if (!this->truncate_log().IsInitialized()) return false;
  }
  return true;
}

void ReplicaStatus::Swap(ReplicaStatus* other) {
  if (other != this) {
    std::swap(truncate_epoch_, other->truncate_epoch_);
    std::swap(file_size_, other->file_size_);
    std::swap(max_obj_version_, other->max_obj_version_);
    std::swap(primary_epoch_, other->primary_epoch_);
    objectversions_.Swap(&other->objectversions_);
    std::swap(truncate_log_, other->truncate_log_);
    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 ReplicaStatus::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ReplicaStatus_descriptor_;
  metadata.reflection = ReplicaStatus_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ObjectVersionMapping::kObjectNumberFieldNumber;
const int ObjectVersionMapping::kObjectVersionFieldNumber;
const int ObjectVersionMapping::kOsdUuidsFieldNumber;
#endif  // !_MSC_VER

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

void ObjectVersionMapping::InitAsDefaultInstance() {
}

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

void ObjectVersionMapping::SharedCtor() {
  _cached_size_ = 0;
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const ObjectVersionMapping& ObjectVersionMapping::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

ObjectVersionMapping* ObjectVersionMapping::default_instance_ = NULL;

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

void ObjectVersionMapping::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
  }
  osd_uuids_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ObjectVersionMapping::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 object_number = 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, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_osd_uuids;
        break;
      }

      // repeated string osd_uuids = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_osd_uuids:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_osd_uuids()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->osd_uuids(this->osd_uuids_size() - 1).data(),
            this->osd_uuids(this->osd_uuids_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_osd_uuids;
        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 ObjectVersionMapping::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 object_number = 1;
  if (has_object_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->object_number(), output);
  }

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

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

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

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

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

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

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

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

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

    // required fixed64 object_version = 2;
    if (has_object_version()) {
      total_size += 1 + 8;
    }

  }
  // repeated string osd_uuids = 3;
  total_size += 1 * this->osd_uuids_size();
  for (int i = 0; i < this->osd_uuids_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->osd_uuids(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 ObjectVersionMapping::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ObjectVersionMapping* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ObjectVersionMapping*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ObjectVersionMapping::MergeFrom(const ObjectVersionMapping& from) {
  GOOGLE_CHECK_NE(&from, this);
  osd_uuids_.MergeFrom(from.osd_uuids_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void ObjectVersionMapping::Swap(ObjectVersionMapping* other) {
  if (other != this) {
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_version_);
    osd_uuids_.Swap(&other->osd_uuids_);
    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 ObjectVersionMapping::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ObjectVersionMapping_descriptor_;
  metadata.reflection = ObjectVersionMapping_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int AuthoritativeReplicaState::kTruncateEpochFieldNumber;
const int AuthoritativeReplicaState::kMaxObjVersionFieldNumber;
const int AuthoritativeReplicaState::kObjectVersionsFieldNumber;
const int AuthoritativeReplicaState::kTruncateLogFieldNumber;
#endif  // !_MSC_VER

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

void AuthoritativeReplicaState::InitAsDefaultInstance() {
  truncate_log_ = const_cast< ::xtreemfs::pbrpc::TruncateLog*>(&::xtreemfs::pbrpc::TruncateLog::default_instance());
}

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

void AuthoritativeReplicaState::SharedCtor() {
  _cached_size_ = 0;
  truncate_epoch_ = GOOGLE_ULONGLONG(0);
  max_obj_version_ = GOOGLE_ULONGLONG(0);
  truncate_log_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void AuthoritativeReplicaState::SharedDtor() {
  if (this != default_instance_) {
    delete truncate_log_;
  }
}

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

const AuthoritativeReplicaState& AuthoritativeReplicaState::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

AuthoritativeReplicaState* AuthoritativeReplicaState::default_instance_ = NULL;

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

void AuthoritativeReplicaState::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    truncate_epoch_ = GOOGLE_ULONGLONG(0);
    max_obj_version_ = GOOGLE_ULONGLONG(0);
    if (has_truncate_log()) {
      if (truncate_log_ != NULL) truncate_log_->::xtreemfs::pbrpc::TruncateLog::Clear();
    }
  }
  objectversions_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool AuthoritativeReplicaState::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 truncate_epoch = 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, &truncate_epoch_)));
          set_has_truncate_epoch();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_objectVersions;
        break;
      }

      // repeated .xtreemfs.pbrpc.ObjectVersionMapping objectVersions = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_objectVersions:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_objectversions()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_objectVersions;
        if (input->ExpectTag(26)) goto parse_truncate_log;
        break;
      }

      // required .xtreemfs.pbrpc.TruncateLog truncate_log = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_truncate_log:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_truncate_log()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_max_obj_version;
        break;
      }

      // required fixed64 max_obj_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_max_obj_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &max_obj_version_)));
          set_has_max_obj_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 AuthoritativeReplicaState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 truncate_epoch = 1;
  if (has_truncate_epoch()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->truncate_epoch(), output);
  }

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

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

  // required fixed64 max_obj_version = 4;
  if (has_max_obj_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->max_obj_version(), output);
  }

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

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

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

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

  // required fixed64 max_obj_version = 4;
  if (has_max_obj_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->max_obj_version(), target);
  }

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

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

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

    // required fixed64 max_obj_version = 4;
    if (has_max_obj_version()) {
      total_size += 1 + 8;
    }

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

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

void AuthoritativeReplicaState::MergeFrom(const AuthoritativeReplicaState& from) {
  GOOGLE_CHECK_NE(&from, this);
  objectversions_.MergeFrom(from.objectversions_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_truncate_epoch()) {
      set_truncate_epoch(from.truncate_epoch());
    }
    if (from.has_max_obj_version()) {
      set_max_obj_version(from.max_obj_version());
    }
    if (from.has_truncate_log()) {
      mutable_truncate_log()->::xtreemfs::pbrpc::TruncateLog::MergeFrom(from.truncate_log());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  for (int i = 0; i < objectversions_size(); i++) {
    if (!this->objectversions(i).IsInitialized()) return false;
  }
  if (has_truncate_log()) {
    if (!this->truncate_log().IsInitialized()) return false;
  }
  return true;
}

void AuthoritativeReplicaState::Swap(AuthoritativeReplicaState* other) {
  if (other != this) {
    std::swap(truncate_epoch_, other->truncate_epoch_);
    std::swap(max_obj_version_, other->max_obj_version_);
    objectversions_.Swap(&other->objectversions_);
    std::swap(truncate_log_, other->truncate_log_);
    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 AuthoritativeReplicaState::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AuthoritativeReplicaState_descriptor_;
  metadata.reflection = AuthoritativeReplicaState_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int InternalReadLocalResponse::kDataFieldNumber;
const int InternalReadLocalResponse::kObjectSetFieldNumber;
#endif  // !_MSC_VER

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

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

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

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

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

void InternalReadLocalResponse::SharedDtor() {
  if (this != default_instance_) {
    delete data_;
  }
}

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

const InternalReadLocalResponse& InternalReadLocalResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

InternalReadLocalResponse* InternalReadLocalResponse::default_instance_ = NULL;

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

void InternalReadLocalResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_data()) {
      if (data_ != NULL) data_->::xtreemfs::pbrpc::ObjectData::Clear();
    }
  }
  object_set_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool InternalReadLocalResponse::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.ObjectData data = 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_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_object_set;
        break;
      }

      // repeated .xtreemfs.pbrpc.ObjectList object_set = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_object_set:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_object_set()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_object_set;
        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 InternalReadLocalResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.ObjectData data = 1;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->data(), output);
  }

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

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

::google::protobuf::uint8* InternalReadLocalResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.ObjectData data = 1;
  if (has_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->data(), target);
  }

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

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

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

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

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

void InternalReadLocalResponse::MergeFrom(const InternalReadLocalResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  object_set_.MergeFrom(from.object_set_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_data()) {
      mutable_data()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

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

void InternalReadLocalResponse::Swap(InternalReadLocalResponse* other) {
  if (other != this) {
    std::swap(data_, other->data_);
    object_set_.Swap(&other->object_set_);
    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 InternalReadLocalResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = InternalReadLocalResponse_descriptor_;
  metadata.reflection = InternalReadLocalResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int readRequest::kFileCredentialsFieldNumber;
const int readRequest::kFileIdFieldNumber;
const int readRequest::kObjectNumberFieldNumber;
const int readRequest::kObjectVersionFieldNumber;
const int readRequest::kOffsetFieldNumber;
const int readRequest::kLengthFieldNumber;
#endif  // !_MSC_VER

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

void readRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void readRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  offset_ = 0u;
  length_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void readRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const readRequest& readRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

readRequest* readRequest::default_instance_ = NULL;

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

void readRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
    offset_ = 0u;
    length_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool readRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_offset;
        break;
      }

      // required fixed32 offset = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(53)) goto parse_length;
        break;
      }

      // required fixed32 length = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &length_)));
          set_has_length();
        } 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 readRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

  // required fixed32 length = 6;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->length(), output);
  }

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

::google::protobuf::uint8* readRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

  // required fixed32 length = 6;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->length(), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

    // required fixed64 object_version = 4;
    if (has_object_version()) {
      total_size += 1 + 8;
    }

    // required fixed32 offset = 5;
    if (has_offset()) {
      total_size += 1 + 4;
    }

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

void readRequest::MergeFrom(const readRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_length()) {
      set_length(from.length());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void readRequest::Swap(readRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_version_);
    std::swap(offset_, other->offset_);
    std::swap(length_, other->length_);
    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 readRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = readRequest_descriptor_;
  metadata.reflection = readRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int truncateRequest::kFileCredentialsFieldNumber;
const int truncateRequest::kFileIdFieldNumber;
const int truncateRequest::kNewFileSizeFieldNumber;
#endif  // !_MSC_VER

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

void truncateRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void truncateRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  new_file_size_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void truncateRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const truncateRequest& truncateRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

truncateRequest* truncateRequest::default_instance_ = NULL;

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

void truncateRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    new_file_size_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool truncateRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 new_file_size = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_new_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_file_size_)));
          set_has_new_file_size();
        } 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 truncateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

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

::google::protobuf::uint8* truncateRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

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

void truncateRequest::MergeFrom(const truncateRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_new_file_size()) {
      set_new_file_size(from.new_file_size());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void truncateRequest::Swap(truncateRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(new_file_size_, other->new_file_size_);
    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 truncateRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = truncateRequest_descriptor_;
  metadata.reflection = truncateRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int unlink_osd_Request::kFileCredentialsFieldNumber;
const int unlink_osd_Request::kFileIdFieldNumber;
#endif  // !_MSC_VER

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

void unlink_osd_Request::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

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

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

void unlink_osd_Request::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const unlink_osd_Request& unlink_osd_Request::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

unlink_osd_Request* unlink_osd_Request::default_instance_ = NULL;

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

void unlink_osd_Request::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool unlink_osd_Request::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().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 unlink_osd_Request::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

::google::protobuf::uint8* unlink_osd_Request::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

void unlink_osd_Request::MergeFrom(const unlink_osd_Request& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int writeRequest::kFileCredentialsFieldNumber;
const int writeRequest::kFileIdFieldNumber;
const int writeRequest::kObjectNumberFieldNumber;
const int writeRequest::kObjectVersionFieldNumber;
const int writeRequest::kOffsetFieldNumber;
const int writeRequest::kLeaseTimeoutFieldNumber;
const int writeRequest::kObjectDataFieldNumber;
#endif  // !_MSC_VER

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

void writeRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
  object_data_ = const_cast< ::xtreemfs::pbrpc::ObjectData*>(&::xtreemfs::pbrpc::ObjectData::default_instance());
}

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

void writeRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  offset_ = 0u;
  lease_timeout_ = GOOGLE_ULONGLONG(0);
  object_data_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void writeRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
    delete object_data_;
  }
}

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

const writeRequest& writeRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

writeRequest* writeRequest::default_instance_ = NULL;

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

void writeRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
    offset_ = 0u;
    lease_timeout_ = GOOGLE_ULONGLONG(0);
    if (has_object_data()) {
      if (object_data_ != NULL) object_data_->::xtreemfs::pbrpc::ObjectData::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool writeRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_offset;
        break;
      }

      // required fixed32 offset = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(49)) goto parse_lease_timeout;
        break;
      }

      // required fixed64 lease_timeout = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_lease_timeout:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &lease_timeout_)));
          set_has_lease_timeout();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_object_data;
        break;
      }

      // required .xtreemfs.pbrpc.ObjectData object_data = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_object_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_object_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 writeRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

  // required fixed64 lease_timeout = 6;
  if (has_lease_timeout()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->lease_timeout(), output);
  }

  // required .xtreemfs.pbrpc.ObjectData object_data = 7;
  if (has_object_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->object_data(), output);
  }

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

::google::protobuf::uint8* writeRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

  // required fixed64 lease_timeout = 6;
  if (has_lease_timeout()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->lease_timeout(), target);
  }

  // required .xtreemfs.pbrpc.ObjectData object_data = 7;
  if (has_object_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->object_data(), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

    // required fixed64 object_version = 4;
    if (has_object_version()) {
      total_size += 1 + 8;
    }

    // required fixed32 offset = 5;
    if (has_offset()) {
      total_size += 1 + 4;
    }

    // required fixed64 lease_timeout = 6;
    if (has_lease_timeout()) {
      total_size += 1 + 8;
    }

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

void writeRequest::MergeFrom(const writeRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_lease_timeout()) {
      set_lease_timeout(from.lease_timeout());
    }
    if (from.has_object_data()) {
      mutable_object_data()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.object_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  if (has_object_data()) {
    if (!this->object_data().IsInitialized()) return false;
  }
  return true;
}

void writeRequest::Swap(writeRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_version_);
    std::swap(offset_, other->offset_);
    std::swap(lease_timeout_, other->lease_timeout_);
    std::swap(object_data_, other->object_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 writeRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = writeRequest_descriptor_;
  metadata.reflection = writeRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_broadcast_gmaxRequest::kFileIdFieldNumber;
const int xtreemfs_broadcast_gmaxRequest::kTruncateEpochFieldNumber;
const int xtreemfs_broadcast_gmaxRequest::kLastObjectFieldNumber;
const int xtreemfs_broadcast_gmaxRequest::kFileSizeFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_broadcast_gmaxRequest::InitAsDefaultInstance() {
}

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

void xtreemfs_broadcast_gmaxRequest::SharedCtor() {
  _cached_size_ = 0;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  truncate_epoch_ = GOOGLE_ULONGLONG(0);
  last_object_ = GOOGLE_ULONGLONG(0);
  file_size_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const xtreemfs_broadcast_gmaxRequest& xtreemfs_broadcast_gmaxRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_broadcast_gmaxRequest* xtreemfs_broadcast_gmaxRequest::default_instance_ = NULL;

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

void xtreemfs_broadcast_gmaxRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    truncate_epoch_ = GOOGLE_ULONGLONG(0);
    last_object_ = GOOGLE_ULONGLONG(0);
    file_size_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

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

      // required fixed64 truncate_epoch = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_truncate_epoch:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &truncate_epoch_)));
          set_has_truncate_epoch();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_last_object;
        break;
      }

      // required fixed64 last_object = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_last_object:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &last_object_)));
          set_has_last_object();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_file_size;
        break;
      }

      // required fixed64 file_size = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &file_size_)));
          set_has_file_size();
        } 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 xtreemfs_broadcast_gmaxRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string file_id = 1;
  if (has_file_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_id().data(), this->file_id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->file_id(), output);
  }

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

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

  // required fixed64 file_size = 4;
  if (has_file_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->file_size(), output);
  }

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

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

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

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

  // required fixed64 file_size = 4;
  if (has_file_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->file_size(), target);
  }

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

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

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

    // required fixed64 truncate_epoch = 2;
    if (has_truncate_epoch()) {
      total_size += 1 + 8;
    }

    // required fixed64 last_object = 3;
    if (has_last_object()) {
      total_size += 1 + 8;
    }

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

void xtreemfs_broadcast_gmaxRequest::MergeFrom(const xtreemfs_broadcast_gmaxRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_truncate_epoch()) {
      set_truncate_epoch(from.truncate_epoch());
    }
    if (from.has_last_object()) {
      set_last_object(from.last_object());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void xtreemfs_broadcast_gmaxRequest::Swap(xtreemfs_broadcast_gmaxRequest* other) {
  if (other != this) {
    std::swap(file_id_, other->file_id_);
    std::swap(truncate_epoch_, other->truncate_epoch_);
    std::swap(last_object_, other->last_object_);
    std::swap(file_size_, other->file_size_);
    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 xtreemfs_broadcast_gmaxRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_broadcast_gmaxRequest_descriptor_;
  metadata.reflection = xtreemfs_broadcast_gmaxRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_check_objectRequest::kFileCredentialsFieldNumber;
const int xtreemfs_check_objectRequest::kFileIdFieldNumber;
const int xtreemfs_check_objectRequest::kObjectNumberFieldNumber;
const int xtreemfs_check_objectRequest::kObjectVersionFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_check_objectRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_check_objectRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_check_objectRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_check_objectRequest& xtreemfs_check_objectRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_check_objectRequest* xtreemfs_check_objectRequest::default_instance_ = NULL;

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

void xtreemfs_check_objectRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_check_objectRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_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 xtreemfs_check_objectRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

::google::protobuf::uint8* xtreemfs_check_objectRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

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

void xtreemfs_check_objectRequest::MergeFrom(const xtreemfs_check_objectRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_check_objectRequest::Swap(xtreemfs_check_objectRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_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 xtreemfs_check_objectRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_check_objectRequest_descriptor_;
  metadata.reflection = xtreemfs_check_objectRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_cleanup_get_resultsResponse::kResultsFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_cleanup_get_resultsResponse::InitAsDefaultInstance() {
}

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

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

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

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

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

const xtreemfs_cleanup_get_resultsResponse& xtreemfs_cleanup_get_resultsResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_cleanup_get_resultsResponse* xtreemfs_cleanup_get_resultsResponse::default_instance_ = NULL;

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

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

bool xtreemfs_cleanup_get_resultsResponse::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 string results = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_results:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_results()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->results(this->results_size() - 1).data(),
            this->results(this->results_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_results;
        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 xtreemfs_cleanup_get_resultsResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated string results = 1;
  for (int i = 0; i < this->results_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->results(i).data(), this->results(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->results(i), output);
  }

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

::google::protobuf::uint8* xtreemfs_cleanup_get_resultsResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated string results = 1;
  for (int i = 0; i < this->results_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->results(i).data(), this->results(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1, this->results(i), target);
  }

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

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

  // repeated string results = 1;
  total_size += 1 * this->results_size();
  for (int i = 0; i < this->results_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->results(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 xtreemfs_cleanup_get_resultsResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const xtreemfs_cleanup_get_resultsResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const xtreemfs_cleanup_get_resultsResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

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

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

bool xtreemfs_cleanup_get_resultsResponse::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_cleanup_is_runningResponse::kIsRunningFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_cleanup_is_runningResponse::InitAsDefaultInstance() {
}

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

void xtreemfs_cleanup_is_runningResponse::SharedCtor() {
  _cached_size_ = 0;
  is_running_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const xtreemfs_cleanup_is_runningResponse& xtreemfs_cleanup_is_runningResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_cleanup_is_runningResponse* xtreemfs_cleanup_is_runningResponse::default_instance_ = NULL;

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

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

bool xtreemfs_cleanup_is_runningResponse::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 bool is_running = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_running_)));
          set_has_is_running();
        } 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 xtreemfs_cleanup_is_runningResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required bool is_running = 1;
  if (has_is_running()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->is_running(), output);
  }

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

::google::protobuf::uint8* xtreemfs_cleanup_is_runningResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required bool is_running = 1;
  if (has_is_running()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->is_running(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bool is_running = 1;
    if (has_is_running()) {
      total_size += 1 + 1;
    }

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

void xtreemfs_cleanup_is_runningResponse::MergeFrom(const xtreemfs_cleanup_is_runningResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_is_running()) {
      set_is_running(from.is_running());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_cleanup_startRequest::kRemoveZombiesFieldNumber;
const int xtreemfs_cleanup_startRequest::kRemoveUnavailVolumeFieldNumber;
const int xtreemfs_cleanup_startRequest::kLostAndFoundFieldNumber;
const int xtreemfs_cleanup_startRequest::kDeleteMetadataFieldNumber;
const int xtreemfs_cleanup_startRequest::kMetadataTimeoutFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_cleanup_startRequest::InitAsDefaultInstance() {
}

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

void xtreemfs_cleanup_startRequest::SharedCtor() {
  _cached_size_ = 0;
  remove_zombies_ = false;
  remove_unavail_volume_ = false;
  lost_and_found_ = false;
  delete_metadata_ = false;
  metadata_timeout_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const xtreemfs_cleanup_startRequest& xtreemfs_cleanup_startRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_cleanup_startRequest* xtreemfs_cleanup_startRequest::default_instance_ = NULL;

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

void xtreemfs_cleanup_startRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    remove_zombies_ = false;
    remove_unavail_volume_ = false;
    lost_and_found_ = false;
    delete_metadata_ = false;
    metadata_timeout_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_cleanup_startRequest::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 bool remove_zombies = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &remove_zombies_)));
          set_has_remove_zombies();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_remove_unavail_volume;
        break;
      }

      // required bool remove_unavail_volume = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_remove_unavail_volume:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &remove_unavail_volume_)));
          set_has_remove_unavail_volume();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_lost_and_found;
        break;
      }

      // required bool lost_and_found = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_lost_and_found:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &lost_and_found_)));
          set_has_lost_and_found();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_delete_metadata;
        break;
      }

      // required bool delete_metadata = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_delete_metadata:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &delete_metadata_)));
          set_has_delete_metadata();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_metadata_timeout;
        break;
      }

      // required fixed32 metadata_timeout = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_metadata_timeout:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &metadata_timeout_)));
          set_has_metadata_timeout();
        } 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 xtreemfs_cleanup_startRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required bool remove_zombies = 1;
  if (has_remove_zombies()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->remove_zombies(), output);
  }

  // required bool remove_unavail_volume = 2;
  if (has_remove_unavail_volume()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->remove_unavail_volume(), output);
  }

  // required bool lost_and_found = 3;
  if (has_lost_and_found()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->lost_and_found(), output);
  }

  // required bool delete_metadata = 4;
  if (has_delete_metadata()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->delete_metadata(), output);
  }

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

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

::google::protobuf::uint8* xtreemfs_cleanup_startRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required bool remove_zombies = 1;
  if (has_remove_zombies()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->remove_zombies(), target);
  }

  // required bool remove_unavail_volume = 2;
  if (has_remove_unavail_volume()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->remove_unavail_volume(), target);
  }

  // required bool lost_and_found = 3;
  if (has_lost_and_found()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->lost_and_found(), target);
  }

  // required bool delete_metadata = 4;
  if (has_delete_metadata()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->delete_metadata(), target);
  }

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bool remove_zombies = 1;
    if (has_remove_zombies()) {
      total_size += 1 + 1;
    }

    // required bool remove_unavail_volume = 2;
    if (has_remove_unavail_volume()) {
      total_size += 1 + 1;
    }

    // required bool lost_and_found = 3;
    if (has_lost_and_found()) {
      total_size += 1 + 1;
    }

    // required bool delete_metadata = 4;
    if (has_delete_metadata()) {
      total_size += 1 + 1;
    }

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

void xtreemfs_cleanup_startRequest::MergeFrom(const xtreemfs_cleanup_startRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_remove_zombies()) {
      set_remove_zombies(from.remove_zombies());
    }
    if (from.has_remove_unavail_volume()) {
      set_remove_unavail_volume(from.remove_unavail_volume());
    }
    if (from.has_lost_and_found()) {
      set_lost_and_found(from.lost_and_found());
    }
    if (from.has_delete_metadata()) {
      set_delete_metadata(from.delete_metadata());
    }
    if (from.has_metadata_timeout()) {
      set_metadata_timeout(from.metadata_timeout());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void xtreemfs_cleanup_startRequest::Swap(xtreemfs_cleanup_startRequest* other) {
  if (other != this) {
    std::swap(remove_zombies_, other->remove_zombies_);
    std::swap(remove_unavail_volume_, other->remove_unavail_volume_);
    std::swap(lost_and_found_, other->lost_and_found_);
    std::swap(delete_metadata_, other->delete_metadata_);
    std::swap(metadata_timeout_, other->metadata_timeout_);
    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 xtreemfs_cleanup_startRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_cleanup_startRequest_descriptor_;
  metadata.reflection = xtreemfs_cleanup_startRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_cleanup_statusResponse::kStatusFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_cleanup_statusResponse::InitAsDefaultInstance() {
}

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

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

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

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

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

const xtreemfs_cleanup_statusResponse& xtreemfs_cleanup_statusResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_cleanup_statusResponse* xtreemfs_cleanup_statusResponse::default_instance_ = NULL;

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

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

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

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

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

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

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

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

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

void xtreemfs_cleanup_statusResponse::MergeFrom(const xtreemfs_cleanup_statusResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_status()) {
      set_status(from.status());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_rwr_fetchRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_fetchRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_fetchRequest::kObjectNumberFieldNumber;
const int xtreemfs_rwr_fetchRequest::kObjectVersionFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_fetchRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_rwr_fetchRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_fetchRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_rwr_fetchRequest& xtreemfs_rwr_fetchRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_fetchRequest* xtreemfs_rwr_fetchRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_fetchRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_fetchRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_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 xtreemfs_rwr_fetchRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

::google::protobuf::uint8* xtreemfs_rwr_fetchRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

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

void xtreemfs_rwr_fetchRequest::MergeFrom(const xtreemfs_rwr_fetchRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_fetchRequest::Swap(xtreemfs_rwr_fetchRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_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 xtreemfs_rwr_fetchRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_fetchRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_fetchRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_repair_objectRequest::kFileCredentialsFieldNumber;
const int xtreemfs_repair_objectRequest::kFileIdFieldNumber;
const int xtreemfs_repair_objectRequest::kObjectNumberFieldNumber;
const int xtreemfs_repair_objectRequest::kObjectVersionFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_repair_objectRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_repair_objectRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_repair_objectRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_repair_objectRequest& xtreemfs_repair_objectRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_repair_objectRequest* xtreemfs_repair_objectRequest::default_instance_ = NULL;

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

void xtreemfs_repair_objectRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_repair_objectRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_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 xtreemfs_repair_objectRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

::google::protobuf::uint8* xtreemfs_repair_objectRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

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

void xtreemfs_repair_objectRequest::MergeFrom(const xtreemfs_repair_objectRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_repair_objectRequest::Swap(xtreemfs_repair_objectRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_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 xtreemfs_repair_objectRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_repair_objectRequest_descriptor_;
  metadata.reflection = xtreemfs_repair_objectRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_flease_msgRequest::kSenderHostnameFieldNumber;
const int xtreemfs_rwr_flease_msgRequest::kSenderPortFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_flease_msgRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const xtreemfs_rwr_flease_msgRequest& xtreemfs_rwr_flease_msgRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_flease_msgRequest* xtreemfs_rwr_flease_msgRequest::default_instance_ = NULL;

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

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

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

      // required fixed32 sender_port = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_sender_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &sender_port_)));
          set_has_sender_port();
        } 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 xtreemfs_rwr_flease_msgRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string sender_hostname = 1;
  if (has_sender_hostname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->sender_hostname().data(), this->sender_hostname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->sender_hostname(), output);
  }

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

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

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

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

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

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

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

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

void xtreemfs_rwr_flease_msgRequest::MergeFrom(const xtreemfs_rwr_flease_msgRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sender_hostname()) {
      set_sender_hostname(from.sender_hostname());
    }
    if (from.has_sender_port()) {
      set_sender_port(from.sender_port());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_rwr_set_primary_epochRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_set_primary_epochRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_set_primary_epochRequest::kPrimaryEpochFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_set_primary_epochRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_rwr_set_primary_epochRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  primary_epoch_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_set_primary_epochRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_rwr_set_primary_epochRequest& xtreemfs_rwr_set_primary_epochRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_set_primary_epochRequest* xtreemfs_rwr_set_primary_epochRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_set_primary_epochRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    primary_epoch_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_set_primary_epochRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_primary_epoch;
        break;
      }

      // required fixed32 primary_epoch = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_primary_epoch:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &primary_epoch_)));
          set_has_primary_epoch();
        } 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 xtreemfs_rwr_set_primary_epochRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

  // required fixed32 primary_epoch = 3;
  if (has_primary_epoch()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->primary_epoch(), output);
  }

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

::google::protobuf::uint8* xtreemfs_rwr_set_primary_epochRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

  // required fixed32 primary_epoch = 3;
  if (has_primary_epoch()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->primary_epoch(), target);
  }

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

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

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

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

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

void xtreemfs_rwr_set_primary_epochRequest::MergeFrom(const xtreemfs_rwr_set_primary_epochRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_primary_epoch()) {
      set_primary_epoch(from.primary_epoch());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_set_primary_epochRequest::Swap(xtreemfs_rwr_set_primary_epochRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(primary_epoch_, other->primary_epoch_);
    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 xtreemfs_rwr_set_primary_epochRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_set_primary_epochRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_set_primary_epochRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_statusRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_statusRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_statusRequest::kMaxLocalObjVersionFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_statusRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_rwr_statusRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  max_local_obj_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_statusRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_rwr_statusRequest& xtreemfs_rwr_statusRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_statusRequest* xtreemfs_rwr_statusRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_statusRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    max_local_obj_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_statusRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 max_local_obj_version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_max_local_obj_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &max_local_obj_version_)));
          set_has_max_local_obj_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 xtreemfs_rwr_statusRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

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

::google::protobuf::uint8* xtreemfs_rwr_statusRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

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

void xtreemfs_rwr_statusRequest::MergeFrom(const xtreemfs_rwr_statusRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_max_local_obj_version()) {
      set_max_local_obj_version(from.max_local_obj_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_statusRequest::Swap(xtreemfs_rwr_statusRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(max_local_obj_version_, other->max_local_obj_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 xtreemfs_rwr_statusRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_statusRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_statusRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_truncateRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_truncateRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_truncateRequest::kNewFileSizeFieldNumber;
const int xtreemfs_rwr_truncateRequest::kObjectVersionFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_truncateRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_rwr_truncateRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  new_file_size_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_truncateRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_rwr_truncateRequest& xtreemfs_rwr_truncateRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_truncateRequest* xtreemfs_rwr_truncateRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_truncateRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    new_file_size_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_truncateRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 new_file_size = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_new_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_file_size_)));
          set_has_new_file_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_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 xtreemfs_rwr_truncateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

::google::protobuf::uint8* xtreemfs_rwr_truncateRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

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

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

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

    // required fixed64 new_file_size = 3;
    if (has_new_file_size()) {
      total_size += 1 + 8;
    }

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

void xtreemfs_rwr_truncateRequest::MergeFrom(const xtreemfs_rwr_truncateRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_new_file_size()) {
      set_new_file_size(from.new_file_size());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_truncateRequest::Swap(xtreemfs_rwr_truncateRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(new_file_size_, other->new_file_size_);
    std::swap(object_version_, other->object_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 xtreemfs_rwr_truncateRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_truncateRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_truncateRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_updateRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_updateRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_updateRequest::kNewFileSizeFieldNumber;
const int xtreemfs_rwr_updateRequest::kObjectNumberFieldNumber;
const int xtreemfs_rwr_updateRequest::kObjectVersionFieldNumber;
const int xtreemfs_rwr_updateRequest::kOffsetFieldNumber;
const int xtreemfs_rwr_updateRequest::kObjFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_updateRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
  obj_ = const_cast< ::xtreemfs::pbrpc::ObjectData*>(&::xtreemfs::pbrpc::ObjectData::default_instance());
}

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

void xtreemfs_rwr_updateRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  new_file_size_ = GOOGLE_ULONGLONG(0);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  offset_ = 0u;
  obj_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_updateRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
    delete obj_;
  }
}

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

const xtreemfs_rwr_updateRequest& xtreemfs_rwr_updateRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_updateRequest* xtreemfs_rwr_updateRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_updateRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    new_file_size_ = GOOGLE_ULONGLONG(0);
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
    offset_ = 0u;
    if (has_obj()) {
      if (obj_ != NULL) obj_->::xtreemfs::pbrpc::ObjectData::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_updateRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 new_file_size = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_new_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_file_size_)));
          set_has_new_file_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_offset;
        break;
      }

      // required fixed32 offset = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_obj;
        break;
      }

      // required .xtreemfs.pbrpc.ObjectData obj = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_obj:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_obj()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(57)) goto parse_object_number;
        break;
      }

      // required fixed64 object_number = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } 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 xtreemfs_rwr_updateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

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

  // required fixed64 object_number = 7;
  if (has_object_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(7, this->object_number(), output);
  }

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

::google::protobuf::uint8* xtreemfs_rwr_updateRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

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

  // required fixed64 object_number = 7;
  if (has_object_number()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(7, this->object_number(), target);
  }

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

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

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

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

    // required fixed64 new_file_size = 3;
    if (has_new_file_size()) {
      total_size += 1 + 8;
    }

    // required fixed64 object_number = 7;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

    // required fixed64 object_version = 4;
    if (has_object_version()) {
      total_size += 1 + 8;
    }

    // required fixed32 offset = 5;
    if (has_offset()) {
      total_size += 1 + 4;
    }

    // required .xtreemfs.pbrpc.ObjectData obj = 6;
    if (has_obj()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->obj());
    }

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

void xtreemfs_rwr_updateRequest::MergeFrom(const xtreemfs_rwr_updateRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_new_file_size()) {
      set_new_file_size(from.new_file_size());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_obj()) {
      mutable_obj()->::xtreemfs::pbrpc::ObjectData::MergeFrom(from.obj());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  if (has_obj()) {
    if (!this->obj().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_updateRequest::Swap(xtreemfs_rwr_updateRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(new_file_size_, other->new_file_size_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_version_);
    std::swap(offset_, other->offset_);
    std::swap(obj_, other->obj_);
    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 xtreemfs_rwr_updateRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_updateRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_updateRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_internal_get_gmaxRequest::kFileCredentialsFieldNumber;
const int xtreemfs_internal_get_gmaxRequest::kFileIdFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_get_gmaxRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

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

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

void xtreemfs_internal_get_gmaxRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_internal_get_gmaxRequest& xtreemfs_internal_get_gmaxRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_get_gmaxRequest* xtreemfs_internal_get_gmaxRequest::default_instance_ = NULL;

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

void xtreemfs_internal_get_gmaxRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_internal_get_gmaxRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().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 xtreemfs_internal_get_gmaxRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

::google::protobuf::uint8* xtreemfs_internal_get_gmaxRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

void xtreemfs_internal_get_gmaxRequest::MergeFrom(const xtreemfs_internal_get_gmaxRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_internal_get_file_sizeRequest::kFileCredentialsFieldNumber;
const int xtreemfs_internal_get_file_sizeRequest::kFileIdFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_get_file_sizeRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

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

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

void xtreemfs_internal_get_file_sizeRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_internal_get_file_sizeRequest& xtreemfs_internal_get_file_sizeRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_get_file_sizeRequest* xtreemfs_internal_get_file_sizeRequest::default_instance_ = NULL;

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

void xtreemfs_internal_get_file_sizeRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_internal_get_file_sizeRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().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 xtreemfs_internal_get_file_sizeRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

::google::protobuf::uint8* xtreemfs_internal_get_file_sizeRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

void xtreemfs_internal_get_file_sizeRequest::MergeFrom(const xtreemfs_internal_get_file_sizeRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_internal_get_file_sizeResponse::kFileSizeFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_get_file_sizeResponse::InitAsDefaultInstance() {
}

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

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

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

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

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

const xtreemfs_internal_get_file_sizeResponse& xtreemfs_internal_get_file_sizeResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_get_file_sizeResponse* xtreemfs_internal_get_file_sizeResponse::default_instance_ = NULL;

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

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

bool xtreemfs_internal_get_file_sizeResponse::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 file_size = 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, &file_size_)));
          set_has_file_size();
        } 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 xtreemfs_internal_get_file_sizeResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 file_size = 1;
  if (has_file_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->file_size(), output);
  }

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

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required fixed64 file_size = 1;
    if (has_file_size()) {
      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 xtreemfs_internal_get_file_sizeResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const xtreemfs_internal_get_file_sizeResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const xtreemfs_internal_get_file_sizeResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void xtreemfs_internal_get_file_sizeResponse::MergeFrom(const xtreemfs_internal_get_file_sizeResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_internal_read_localRequest::kFileCredentialsFieldNumber;
const int xtreemfs_internal_read_localRequest::kFileIdFieldNumber;
const int xtreemfs_internal_read_localRequest::kObjectNumberFieldNumber;
const int xtreemfs_internal_read_localRequest::kObjectVersionFieldNumber;
const int xtreemfs_internal_read_localRequest::kOffsetFieldNumber;
const int xtreemfs_internal_read_localRequest::kLengthFieldNumber;
const int xtreemfs_internal_read_localRequest::kAttachObjectListFieldNumber;
const int xtreemfs_internal_read_localRequest::kRequiredObjectsFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_read_localRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_internal_read_localRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  object_number_ = GOOGLE_ULONGLONG(0);
  object_version_ = GOOGLE_ULONGLONG(0);
  offset_ = 0u;
  length_ = 0u;
  attach_object_list_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_internal_read_localRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_internal_read_localRequest& xtreemfs_internal_read_localRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_read_localRequest* xtreemfs_internal_read_localRequest::default_instance_ = NULL;

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

void xtreemfs_internal_read_localRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    object_number_ = GOOGLE_ULONGLONG(0);
    object_version_ = GOOGLE_ULONGLONG(0);
    offset_ = 0u;
    length_ = 0u;
    attach_object_list_ = false;
  }
  required_objects_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_internal_read_localRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

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

      // required fixed64 object_number = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_number_)));
          set_has_object_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(33)) goto parse_object_version;
        break;
      }

      // required fixed64 object_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_object_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &object_version_)));
          set_has_object_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_offset;
        break;
      }

      // required fixed32 offset = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(53)) goto parse_length;
        break;
      }

      // required fixed32 length = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_attach_object_list;
        break;
      }

      // required bool attach_object_list = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_attach_object_list:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &attach_object_list_)));
          set_has_attach_object_list();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_required_objects;
        break;
      }

      // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_required_objects:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_required_objects()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_required_objects;
        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 xtreemfs_internal_read_localRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->object_version(), output);
  }

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

  // required fixed32 length = 6;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->length(), output);
  }

  // required bool attach_object_list = 7;
  if (has_attach_object_list()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->attach_object_list(), output);
  }

  // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8;
  for (int i = 0; i < this->required_objects_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, this->required_objects(i), output);
  }

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

::google::protobuf::uint8* xtreemfs_internal_read_localRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

  // required fixed64 object_version = 4;
  if (has_object_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->object_version(), target);
  }

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

  // required fixed32 length = 6;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->length(), target);
  }

  // required bool attach_object_list = 7;
  if (has_attach_object_list()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->attach_object_list(), target);
  }

  // repeated .xtreemfs.pbrpc.ObjectList required_objects = 8;
  for (int i = 0; i < this->required_objects_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, this->required_objects(i), target);
  }

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

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

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

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

    // required fixed64 object_number = 3;
    if (has_object_number()) {
      total_size += 1 + 8;
    }

    // required fixed64 object_version = 4;
    if (has_object_version()) {
      total_size += 1 + 8;
    }

    // required fixed32 offset = 5;
    if (has_offset()) {
      total_size += 1 + 4;
    }

    // required fixed32 length = 6;
    if (has_length()) {
      total_size += 1 + 4;
    }

    // required bool attach_object_list = 7;
    if (has_attach_object_list()) {
      total_size += 1 + 1;
    }

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

void xtreemfs_internal_read_localRequest::MergeFrom(const xtreemfs_internal_read_localRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  required_objects_.MergeFrom(from.required_objects_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_object_number()) {
      set_object_number(from.object_number());
    }
    if (from.has_object_version()) {
      set_object_version(from.object_version());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_attach_object_list()) {
      set_attach_object_list(from.attach_object_list());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  for (int i = 0; i < required_objects_size(); i++) {
    if (!this->required_objects(i).IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_internal_read_localRequest::Swap(xtreemfs_internal_read_localRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(object_number_, other->object_number_);
    std::swap(object_version_, other->object_version_);
    std::swap(offset_, other->offset_);
    std::swap(length_, other->length_);
    std::swap(attach_object_list_, other->attach_object_list_);
    required_objects_.Swap(&other->required_objects_);
    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 xtreemfs_internal_read_localRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_internal_read_localRequest_descriptor_;
  metadata.reflection = xtreemfs_internal_read_localRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_internal_get_object_setRequest::kFileCredentialsFieldNumber;
const int xtreemfs_internal_get_object_setRequest::kFileIdFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_get_object_setRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

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

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

void xtreemfs_internal_get_object_setRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_internal_get_object_setRequest& xtreemfs_internal_get_object_setRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_get_object_setRequest* xtreemfs_internal_get_object_setRequest::default_instance_ = NULL;

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

void xtreemfs_internal_get_object_setRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_internal_get_object_setRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().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 xtreemfs_internal_get_object_setRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

::google::protobuf::uint8* xtreemfs_internal_get_object_setRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

void xtreemfs_internal_get_object_setRequest::MergeFrom(const xtreemfs_internal_get_object_setRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_internal_get_fileid_listResponse::kFileIdsFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_internal_get_fileid_listResponse::InitAsDefaultInstance() {
}

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

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

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

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

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

const xtreemfs_internal_get_fileid_listResponse& xtreemfs_internal_get_fileid_listResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_internal_get_fileid_listResponse* xtreemfs_internal_get_fileid_listResponse::default_instance_ = NULL;

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

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

bool xtreemfs_internal_get_fileid_listResponse::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 string file_ids = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_ids:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_file_ids()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_ids(this->file_ids_size() - 1).data(),
            this->file_ids(this->file_ids_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_file_ids;
        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 xtreemfs_internal_get_fileid_listResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated string file_ids = 1;
  for (int i = 0; i < this->file_ids_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->file_ids(i).data(), this->file_ids(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->file_ids(i), output);
  }

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

::google::protobuf::uint8* xtreemfs_internal_get_fileid_listResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated string file_ids = 1;
  for (int i = 0; i < this->file_ids_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_ids(i).data(), this->file_ids(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1, this->file_ids(i), target);
  }

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

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

  // repeated string file_ids = 1;
  total_size += 1 * this->file_ids_size();
  for (int i = 0; i < this->file_ids_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->file_ids(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 xtreemfs_internal_get_fileid_listResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const xtreemfs_internal_get_fileid_listResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const xtreemfs_internal_get_fileid_listResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

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

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

bool xtreemfs_internal_get_fileid_listResponse::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int lockRequest::kFileCredentialsFieldNumber;
const int lockRequest::kLockRequestFieldNumber;
#endif  // !_MSC_VER

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

void lockRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
  lock_request_ = const_cast< ::xtreemfs::pbrpc::Lock*>(&::xtreemfs::pbrpc::Lock::default_instance());
}

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

void lockRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  lock_request_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void lockRequest::SharedDtor() {
  if (this != default_instance_) {
    delete file_credentials_;
    delete lock_request_;
  }
}

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

const lockRequest& lockRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

lockRequest* lockRequest::default_instance_ = NULL;

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

void lockRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_lock_request()) {
      if (lock_request_ != NULL) lock_request_->::xtreemfs::pbrpc::Lock::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool lockRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_lock_request;
        break;
      }

      // required .xtreemfs.pbrpc.Lock lock_request = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_lock_request:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_lock_request()));
        } 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 lockRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

  // required .xtreemfs.pbrpc.Lock lock_request = 2;
  if (has_lock_request()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->lock_request(), output);
  }

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

::google::protobuf::uint8* lockRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

  // required .xtreemfs.pbrpc.Lock lock_request = 2;
  if (has_lock_request()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->lock_request(), target);
  }

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

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

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

    // required .xtreemfs.pbrpc.Lock lock_request = 2;
    if (has_lock_request()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->lock_request());
    }

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

void lockRequest::MergeFrom(const lockRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_lock_request()) {
      mutable_lock_request()->::xtreemfs::pbrpc::Lock::MergeFrom(from.lock_request());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  if (has_lock_request()) {
    if (!this->lock_request().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_pingMesssage::kCoordinatesFieldNumber;
const int xtreemfs_pingMesssage::kRequestResponseFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_pingMesssage::InitAsDefaultInstance() {
  coordinates_ = const_cast< ::xtreemfs::pbrpc::VivaldiCoordinates*>(&::xtreemfs::pbrpc::VivaldiCoordinates::default_instance());
}

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

void xtreemfs_pingMesssage::SharedCtor() {
  _cached_size_ = 0;
  coordinates_ = NULL;
  request_response_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_pingMesssage::SharedDtor() {
  if (this != default_instance_) {
    delete coordinates_;
  }
}

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

const xtreemfs_pingMesssage& xtreemfs_pingMesssage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_pingMesssage* xtreemfs_pingMesssage::default_instance_ = NULL;

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

void xtreemfs_pingMesssage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_coordinates()) {
      if (coordinates_ != NULL) coordinates_->::xtreemfs::pbrpc::VivaldiCoordinates::Clear();
    }
    request_response_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_pingMesssage::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.VivaldiCoordinates coordinates = 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_coordinates()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_request_response;
        break;
      }

      // required bool request_response = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_request_response:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &request_response_)));
          set_has_request_response();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

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

void xtreemfs_pingMesssage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1;
  if (has_coordinates()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->coordinates(), output);
  }

  // required bool request_response = 2;
  if (has_request_response()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->request_response(), output);
  }

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

::google::protobuf::uint8* xtreemfs_pingMesssage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.VivaldiCoordinates coordinates = 1;
  if (has_coordinates()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->coordinates(), target);
  }

  // required bool request_response = 2;
  if (has_request_response()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->request_response(), target);
  }

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

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

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

    // required bool request_response = 2;
    if (has_request_response()) {
      total_size += 1 + 1;
    }

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

void xtreemfs_pingMesssage::MergeFrom(const xtreemfs_pingMesssage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_coordinates()) {
      mutable_coordinates()->::xtreemfs::pbrpc::VivaldiCoordinates::MergeFrom(from.coordinates());
    }
    if (from.has_request_response()) {
      set_request_response(from.request_response());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_coordinates()) {
    if (!this->coordinates().IsInitialized()) return false;
  }
  return true;
}

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

::google::protobuf::Metadata xtreemfs_pingMesssage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_pingMesssage_descriptor_;
  metadata.reflection = xtreemfs_pingMesssage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_auth_stateRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_auth_stateRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_auth_stateRequest::kStateFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_auth_stateRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
  state_ = const_cast< ::xtreemfs::pbrpc::AuthoritativeReplicaState*>(&::xtreemfs::pbrpc::AuthoritativeReplicaState::default_instance());
}

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

void xtreemfs_rwr_auth_stateRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  state_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_auth_stateRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
    delete state_;
  }
}

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

const xtreemfs_rwr_auth_stateRequest& xtreemfs_rwr_auth_stateRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_auth_stateRequest* xtreemfs_rwr_auth_stateRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_auth_stateRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    if (has_state()) {
      if (state_ != NULL) state_->::xtreemfs::pbrpc::AuthoritativeReplicaState::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_auth_stateRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_state;
        break;
      }

      // required .xtreemfs.pbrpc.AuthoritativeReplicaState state = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_state:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_state()));
        } 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 xtreemfs_rwr_auth_stateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

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

::google::protobuf::uint8* xtreemfs_rwr_auth_stateRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

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

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

void xtreemfs_rwr_auth_stateRequest::MergeFrom(const xtreemfs_rwr_auth_stateRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_state()) {
      mutable_state()->::xtreemfs::pbrpc::AuthoritativeReplicaState::MergeFrom(from.state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  if (has_state()) {
    if (!this->state().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_auth_stateRequest::Swap(xtreemfs_rwr_auth_stateRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(state_, other->state_);
    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 xtreemfs_rwr_auth_stateRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_auth_stateRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_auth_stateRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_rwr_reset_completeRequest::kFileCredentialsFieldNumber;
const int xtreemfs_rwr_reset_completeRequest::kFileIdFieldNumber;
const int xtreemfs_rwr_reset_completeRequest::kPrimaryEpochFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_rwr_reset_completeRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

void xtreemfs_rwr_reset_completeRequest::SharedCtor() {
  _cached_size_ = 0;
  file_credentials_ = NULL;
  file_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  primary_epoch_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_rwr_reset_completeRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_rwr_reset_completeRequest& xtreemfs_rwr_reset_completeRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_rwr_reset_completeRequest* xtreemfs_rwr_reset_completeRequest::default_instance_ = NULL;

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

void xtreemfs_rwr_reset_completeRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
    primary_epoch_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_rwr_reset_completeRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_primary_epoch;
        break;
      }

      // required fixed32 primary_epoch = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_primary_epoch:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &primary_epoch_)));
          set_has_primary_epoch();
        } 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 xtreemfs_rwr_reset_completeRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

  // required fixed32 primary_epoch = 3;
  if (has_primary_epoch()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->primary_epoch(), output);
  }

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

::google::protobuf::uint8* xtreemfs_rwr_reset_completeRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

  // required fixed32 primary_epoch = 3;
  if (has_primary_epoch()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->primary_epoch(), target);
  }

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

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

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

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

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

void xtreemfs_rwr_reset_completeRequest::MergeFrom(const xtreemfs_rwr_reset_completeRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
    if (from.has_primary_epoch()) {
      set_primary_epoch(from.primary_epoch());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

void xtreemfs_rwr_reset_completeRequest::Swap(xtreemfs_rwr_reset_completeRequest* other) {
  if (other != this) {
    std::swap(file_credentials_, other->file_credentials_);
    std::swap(file_id_, other->file_id_);
    std::swap(primary_epoch_, other->primary_epoch_);
    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 xtreemfs_rwr_reset_completeRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = xtreemfs_rwr_reset_completeRequest_descriptor_;
  metadata.reflection = xtreemfs_rwr_reset_completeRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int xtreemfs_xloc_set_invalidateRequest::kFileCredentialsFieldNumber;
const int xtreemfs_xloc_set_invalidateRequest::kFileIdFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_xloc_set_invalidateRequest::InitAsDefaultInstance() {
  file_credentials_ = const_cast< ::xtreemfs::pbrpc::FileCredentials*>(&::xtreemfs::pbrpc::FileCredentials::default_instance());
}

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

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

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

void xtreemfs_xloc_set_invalidateRequest::SharedDtor() {
  if (file_id_ != &::google::protobuf::internal::kEmptyString) {
    delete file_id_;
  }
  if (this != default_instance_) {
    delete file_credentials_;
  }
}

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

const xtreemfs_xloc_set_invalidateRequest& xtreemfs_xloc_set_invalidateRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_xloc_set_invalidateRequest* xtreemfs_xloc_set_invalidateRequest::default_instance_ = NULL;

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

void xtreemfs_xloc_set_invalidateRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_file_credentials()) {
      if (file_credentials_ != NULL) file_credentials_->::xtreemfs::pbrpc::FileCredentials::Clear();
    }
    if (has_file_id()) {
      if (file_id_ != &::google::protobuf::internal::kEmptyString) {
        file_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_xloc_set_invalidateRequest::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.FileCredentials file_credentials = 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_file_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_id;
        break;
      }

      // required string file_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_id().data(), this->file_id().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 xtreemfs_xloc_set_invalidateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->file_credentials(), output);
  }

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

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

::google::protobuf::uint8* xtreemfs_xloc_set_invalidateRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.FileCredentials file_credentials = 1;
  if (has_file_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->file_credentials(), target);
  }

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

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

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

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

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

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

void xtreemfs_xloc_set_invalidateRequest::MergeFrom(const xtreemfs_xloc_set_invalidateRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_file_credentials()) {
      mutable_file_credentials()->::xtreemfs::pbrpc::FileCredentials::MergeFrom(from.file_credentials());
    }
    if (from.has_file_id()) {
      set_file_id(from.file_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_file_credentials()) {
    if (!this->file_credentials().IsInitialized()) return false;
  }
  return true;
}

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


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

#ifndef _MSC_VER
const int xtreemfs_xloc_set_invalidateResponse::kLeaseStateFieldNumber;
const int xtreemfs_xloc_set_invalidateResponse::kReplicaStatusFieldNumber;
#endif  // !_MSC_VER

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

void xtreemfs_xloc_set_invalidateResponse::InitAsDefaultInstance() {
  replica_status_ = const_cast< ::xtreemfs::pbrpc::ReplicaStatus*>(&::xtreemfs::pbrpc::ReplicaStatus::default_instance());
}

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

void xtreemfs_xloc_set_invalidateResponse::SharedCtor() {
  _cached_size_ = 0;
  lease_state_ = 0;
  replica_status_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void xtreemfs_xloc_set_invalidateResponse::SharedDtor() {
  if (this != default_instance_) {
    delete replica_status_;
  }
}

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

const xtreemfs_xloc_set_invalidateResponse& xtreemfs_xloc_set_invalidateResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fOSD_2eproto();
  return *default_instance_;
}

xtreemfs_xloc_set_invalidateResponse* xtreemfs_xloc_set_invalidateResponse::default_instance_ = NULL;

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

void xtreemfs_xloc_set_invalidateResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    lease_state_ = 0;
    if (has_replica_status()) {
      if (replica_status_ != NULL) replica_status_->::xtreemfs::pbrpc::ReplicaStatus::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool xtreemfs_xloc_set_invalidateResponse::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.LeaseState lease_state = 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::LeaseState_IsValid(value)) {
            set_lease_state(static_cast< ::xtreemfs::pbrpc::LeaseState >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_replica_status;
        break;
      }

      // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_replica_status:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_replica_status()));
        } 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 xtreemfs_xloc_set_invalidateResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.LeaseState lease_state = 1;
  if (has_lease_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->lease_state(), output);
  }

  // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2;
  if (has_replica_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->replica_status(), output);
  }

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

::google::protobuf::uint8* xtreemfs_xloc_set_invalidateResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.LeaseState lease_state = 1;
  if (has_lease_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->lease_state(), target);
  }

  // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2;
  if (has_replica_status()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->replica_status(), target);
  }

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

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

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

    // optional .xtreemfs.pbrpc.ReplicaStatus replica_status = 2;
    if (has_replica_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->replica_status());
    }

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

void xtreemfs_xloc_set_invalidateResponse::MergeFrom(const xtreemfs_xloc_set_invalidateResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_lease_state()) {
      set_lease_state(from.lease_state());
    }
    if (from.has_replica_status()) {
      mutable_replica_status()->::xtreemfs::pbrpc::ReplicaStatus::MergeFrom(from.replica_status());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_replica_status()) {
    if (!this->replica_status().IsInitialized()) return false;
  }
  return true;
}

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace pbrpc
}  // namespace xtreemfs

// @@protoc_insertion_point(global_scope)