2294 lines
76 KiB
C++
2294 lines
76 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: pbrpc/RPC.proto
|
|
|
|
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
|
|
#include "pbrpc/RPC.pb.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/wire_format_lite_inl.h>
|
|
#include <google/protobuf/descriptor.h>
|
|
#include <google/protobuf/generated_message_reflection.h>
|
|
#include <google/protobuf/reflection_ops.h>
|
|
#include <google/protobuf/wire_format.h>
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
namespace xtreemfs {
|
|
namespace pbrpc {
|
|
|
|
namespace {
|
|
|
|
const ::google::protobuf::Descriptor* UserCredentials_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
UserCredentials_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* AuthPassword_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
AuthPassword_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* Auth_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
Auth_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* RPCHeader_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
RPCHeader_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* RPCHeader_RequestHeader_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
RPCHeader_RequestHeader_reflection_ = NULL;
|
|
const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse_descriptor_ = NULL;
|
|
const ::google::protobuf::internal::GeneratedMessageReflection*
|
|
RPCHeader_ErrorResponse_reflection_ = NULL;
|
|
const ::google::protobuf::EnumDescriptor* MessageType_descriptor_ = NULL;
|
|
const ::google::protobuf::EnumDescriptor* AuthType_descriptor_ = NULL;
|
|
const ::google::protobuf::EnumDescriptor* ErrorType_descriptor_ = NULL;
|
|
const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor_ = NULL;
|
|
|
|
} // namespace
|
|
|
|
|
|
void protobuf_AssignDesc_pbrpc_2fRPC_2eproto() {
|
|
protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
const ::google::protobuf::FileDescriptor* file =
|
|
::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
|
|
"pbrpc/RPC.proto");
|
|
GOOGLE_CHECK(file != NULL);
|
|
UserCredentials_descriptor_ = file->message_type(0);
|
|
static const int UserCredentials_offsets_[2] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, username_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, groups_),
|
|
};
|
|
UserCredentials_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
UserCredentials_descriptor_,
|
|
UserCredentials::default_instance_,
|
|
UserCredentials_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(UserCredentials));
|
|
AuthPassword_descriptor_ = file->message_type(1);
|
|
static const int AuthPassword_offsets_[1] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, password_),
|
|
};
|
|
AuthPassword_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
AuthPassword_descriptor_,
|
|
AuthPassword::default_instance_,
|
|
AuthPassword_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(AuthPassword));
|
|
Auth_descriptor_ = file->message_type(2);
|
|
static const int Auth_offsets_[3] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_type_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_passwd_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_data_),
|
|
};
|
|
Auth_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
Auth_descriptor_,
|
|
Auth::default_instance_,
|
|
Auth_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(Auth));
|
|
RPCHeader_descriptor_ = file->message_type(3);
|
|
static const int RPCHeader_offsets_[4] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, call_id_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, message_type_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, request_header_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, error_response_),
|
|
};
|
|
RPCHeader_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
RPCHeader_descriptor_,
|
|
RPCHeader::default_instance_,
|
|
RPCHeader_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(RPCHeader));
|
|
RPCHeader_RequestHeader_descriptor_ = RPCHeader_descriptor_->nested_type(0);
|
|
static const int RPCHeader_RequestHeader_offsets_[4] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, interface_id_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, proc_id_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, user_creds_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, auth_data_),
|
|
};
|
|
RPCHeader_RequestHeader_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
RPCHeader_RequestHeader_descriptor_,
|
|
RPCHeader_RequestHeader::default_instance_,
|
|
RPCHeader_RequestHeader_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(RPCHeader_RequestHeader));
|
|
RPCHeader_ErrorResponse_descriptor_ = RPCHeader_descriptor_->nested_type(1);
|
|
static const int RPCHeader_ErrorResponse_offsets_[5] = {
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_type_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, posix_errno_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_message_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, debug_info_),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, redirect_to_server_uuid_),
|
|
};
|
|
RPCHeader_ErrorResponse_reflection_ =
|
|
new ::google::protobuf::internal::GeneratedMessageReflection(
|
|
RPCHeader_ErrorResponse_descriptor_,
|
|
RPCHeader_ErrorResponse::default_instance_,
|
|
RPCHeader_ErrorResponse_offsets_,
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _has_bits_[0]),
|
|
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _unknown_fields_),
|
|
-1,
|
|
::google::protobuf::DescriptorPool::generated_pool(),
|
|
::google::protobuf::MessageFactory::generated_factory(),
|
|
sizeof(RPCHeader_ErrorResponse));
|
|
MessageType_descriptor_ = file->enum_type(0);
|
|
AuthType_descriptor_ = file->enum_type(1);
|
|
ErrorType_descriptor_ = file->enum_type(2);
|
|
POSIXErrno_descriptor_ = file->enum_type(3);
|
|
}
|
|
|
|
namespace {
|
|
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
|
|
inline void protobuf_AssignDescriptorsOnce() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
|
|
&protobuf_AssignDesc_pbrpc_2fRPC_2eproto);
|
|
}
|
|
|
|
void protobuf_RegisterTypes(const ::std::string&) {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
UserCredentials_descriptor_, &UserCredentials::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
AuthPassword_descriptor_, &AuthPassword::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
Auth_descriptor_, &Auth::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
RPCHeader_descriptor_, &RPCHeader::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
RPCHeader_RequestHeader_descriptor_, &RPCHeader_RequestHeader::default_instance());
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
|
|
RPCHeader_ErrorResponse_descriptor_, &RPCHeader_ErrorResponse::default_instance());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto() {
|
|
delete UserCredentials::default_instance_;
|
|
delete UserCredentials_reflection_;
|
|
delete AuthPassword::default_instance_;
|
|
delete AuthPassword_reflection_;
|
|
delete Auth::default_instance_;
|
|
delete Auth_reflection_;
|
|
delete RPCHeader::default_instance_;
|
|
delete RPCHeader_reflection_;
|
|
delete RPCHeader_RequestHeader::default_instance_;
|
|
delete RPCHeader_RequestHeader_reflection_;
|
|
delete RPCHeader_ErrorResponse::default_instance_;
|
|
delete RPCHeader_ErrorResponse_reflection_;
|
|
}
|
|
|
|
void protobuf_AddDesc_pbrpc_2fRPC_2eproto() {
|
|
static bool already_here = false;
|
|
if (already_here) return;
|
|
already_here = true;
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
|
|
"\n\017pbrpc/RPC.proto\022\016xtreemfs.pbrpc\"3\n\017Use"
|
|
"rCredentials\022\020\n\010username\030\001 \002(\t\022\016\n\006groups"
|
|
"\030\002 \003(\t\" \n\014AuthPassword\022\020\n\010password\030\001 \002(\t"
|
|
"\"y\n\004Auth\022+\n\tauth_type\030\001 \002(\0162\030.xtreemfs.p"
|
|
"brpc.AuthType\0221\n\013auth_passwd\030\003 \001(\0132\034.xtr"
|
|
"eemfs.pbrpc.AuthPassword\022\021\n\tauth_data\030\002 "
|
|
"\001(\014\"\270\004\n\tRPCHeader\022\017\n\007call_id\030\001 \002(\007\0221\n\014me"
|
|
"ssage_type\030\002 \002(\0162\033.xtreemfs.pbrpc.Messag"
|
|
"eType\022\?\n\016request_header\030\003 \001(\0132\'.xtreemfs"
|
|
".pbrpc.RPCHeader.RequestHeader\022\?\n\016error_"
|
|
"response\030\004 \001(\0132\'.xtreemfs.pbrpc.RPCHeade"
|
|
"r.ErrorResponse\032\224\001\n\rRequestHeader\022\024\n\014int"
|
|
"erface_id\030\001 \002(\007\022\017\n\007proc_id\030\002 \002(\007\0223\n\nuser"
|
|
"_creds\030\003 \002(\0132\037.xtreemfs.pbrpc.UserCreden"
|
|
"tials\022\'\n\tauth_data\030\004 \002(\0132\024.xtreemfs.pbrp"
|
|
"c.Auth\032\315\001\n\rErrorResponse\022-\n\nerror_type\030\001"
|
|
" \002(\0162\031.xtreemfs.pbrpc.ErrorType\022A\n\013posix"
|
|
"_errno\030\002 \001(\0162\032.xtreemfs.pbrpc.POSIXErrno"
|
|
":\020POSIX_ERROR_NONE\022\025\n\rerror_message\030\003 \001("
|
|
"\t\022\022\n\ndebug_info\030\004 \001(\t\022\037\n\027redirect_to_ser"
|
|
"ver_uuid\030\005 \001(\t*P\n\013MessageType\022\017\n\013RPC_REQ"
|
|
"UEST\020\000\022\030\n\024RPC_RESPONSE_SUCCESS\020\001\022\026\n\022RPC_"
|
|
"RESPONSE_ERROR\020\002*,\n\010AuthType\022\r\n\tAUTH_NON"
|
|
"E\020\000\022\021\n\rAUTH_PASSWORD\020\001*\261\001\n\tErrorType\022\030\n\024"
|
|
"INVALID_INTERFACE_ID\020\001\022\023\n\017INVALID_PROC_I"
|
|
"D\020\002\022\020\n\014GARBAGE_ARGS\020\003\022\017\n\013AUTH_FAILED\020\004\022\031"
|
|
"\n\025INTERNAL_SERVER_ERROR\020\005\022\t\n\005ERRNO\020\006\022\014\n\010"
|
|
"REDIRECT\020\007\022\020\n\014INVALID_VIEW\020\010\022\014\n\010IO_ERROR"
|
|
"\020d*\212\003\n\nPOSIXErrno\022\025\n\020POSIX_ERROR_NONE\020\217N"
|
|
"\022\025\n\021POSIX_ERROR_EPERM\020\001\022\026\n\022POSIX_ERROR_E"
|
|
"NOENT\020\002\022\025\n\021POSIX_ERROR_EINTR\020\004\022\023\n\017POSIX_"
|
|
"ERROR_EIO\020\005\022\026\n\022POSIX_ERROR_EAGAIN\020\013\022\026\n\022P"
|
|
"OSIX_ERROR_EACCES\020\r\022\026\n\022POSIX_ERROR_EEXIS"
|
|
"T\020\021\022\025\n\021POSIX_ERROR_EXDEV\020\022\022\026\n\022POSIX_ERRO"
|
|
"R_ENODEV\020\023\022\027\n\023POSIX_ERROR_ENOTDIR\020\024\022\026\n\022P"
|
|
"OSIX_ERROR_EISDIR\020\025\022\026\n\022POSIX_ERROR_EINVA"
|
|
"L\020\026\022\026\n\022POSIX_ERROR_ENOSPC\020\034\022\031\n\025POSIX_ERR"
|
|
"OR_ENOTEMPTY\020\'\022\027\n\023POSIX_ERROR_ENODATA\020=B"
|
|
"3\n1org.xtreemfs.foundation.pbrpc.generat"
|
|
"edinterfaces", 1572);
|
|
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
|
|
"pbrpc/RPC.proto", &protobuf_RegisterTypes);
|
|
UserCredentials::default_instance_ = new UserCredentials();
|
|
AuthPassword::default_instance_ = new AuthPassword();
|
|
Auth::default_instance_ = new Auth();
|
|
RPCHeader::default_instance_ = new RPCHeader();
|
|
RPCHeader_RequestHeader::default_instance_ = new RPCHeader_RequestHeader();
|
|
RPCHeader_ErrorResponse::default_instance_ = new RPCHeader_ErrorResponse();
|
|
UserCredentials::default_instance_->InitAsDefaultInstance();
|
|
AuthPassword::default_instance_->InitAsDefaultInstance();
|
|
Auth::default_instance_->InitAsDefaultInstance();
|
|
RPCHeader::default_instance_->InitAsDefaultInstance();
|
|
RPCHeader_RequestHeader::default_instance_->InitAsDefaultInstance();
|
|
RPCHeader_ErrorResponse::default_instance_->InitAsDefaultInstance();
|
|
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fRPC_2eproto);
|
|
}
|
|
|
|
// Force AddDescriptors() to be called at static initialization time.
|
|
struct StaticDescriptorInitializer_pbrpc_2fRPC_2eproto {
|
|
StaticDescriptorInitializer_pbrpc_2fRPC_2eproto() {
|
|
protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
}
|
|
} static_descriptor_initializer_pbrpc_2fRPC_2eproto_;
|
|
const ::google::protobuf::EnumDescriptor* MessageType_descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return MessageType_descriptor_;
|
|
}
|
|
bool MessageType_IsValid(int value) {
|
|
switch(value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const ::google::protobuf::EnumDescriptor* AuthType_descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return AuthType_descriptor_;
|
|
}
|
|
bool AuthType_IsValid(int value) {
|
|
switch(value) {
|
|
case 0:
|
|
case 1:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const ::google::protobuf::EnumDescriptor* ErrorType_descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return ErrorType_descriptor_;
|
|
}
|
|
bool ErrorType_IsValid(int value) {
|
|
switch(value) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 100:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return POSIXErrno_descriptor_;
|
|
}
|
|
bool POSIXErrno_IsValid(int value) {
|
|
switch(value) {
|
|
case 1:
|
|
case 2:
|
|
case 4:
|
|
case 5:
|
|
case 11:
|
|
case 13:
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 28:
|
|
case 39:
|
|
case 61:
|
|
case 9999:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int UserCredentials::kUsernameFieldNumber;
|
|
const int UserCredentials::kGroupsFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
UserCredentials::UserCredentials()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void UserCredentials::InitAsDefaultInstance() {
|
|
}
|
|
|
|
UserCredentials::UserCredentials(const UserCredentials& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void UserCredentials::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
UserCredentials::~UserCredentials() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void UserCredentials::SharedDtor() {
|
|
if (username_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete username_;
|
|
}
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void UserCredentials::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* UserCredentials::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return UserCredentials_descriptor_;
|
|
}
|
|
|
|
const UserCredentials& UserCredentials::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
UserCredentials* UserCredentials::default_instance_ = NULL;
|
|
|
|
UserCredentials* UserCredentials::New() const {
|
|
return new UserCredentials;
|
|
}
|
|
|
|
void UserCredentials::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (has_username()) {
|
|
if (username_ != &::google::protobuf::internal::kEmptyString) {
|
|
username_->clear();
|
|
}
|
|
}
|
|
}
|
|
groups_.Clear();
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool UserCredentials::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required string username = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_username()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->username().data(), this->username().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_groups;
|
|
break;
|
|
}
|
|
|
|
// repeated string groups = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_groups:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->add_groups()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->groups(this->groups_size() - 1).data(),
|
|
this->groups(this->groups_size() - 1).length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_groups;
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void UserCredentials::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required string username = 1;
|
|
if (has_username()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->username().data(), this->username().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
1, this->username(), output);
|
|
}
|
|
|
|
// repeated string groups = 2;
|
|
for (int i = 0; i < this->groups_size(); i++) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->groups(i).data(), this->groups(i).length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
2, this->groups(i), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required string username = 1;
|
|
if (has_username()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->username().data(), this->username().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
1, this->username(), target);
|
|
}
|
|
|
|
// repeated string groups = 2;
|
|
for (int i = 0; i < this->groups_size(); i++) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->groups(i).data(), this->groups(i).length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteStringToArray(2, this->groups(i), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int UserCredentials::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required string username = 1;
|
|
if (has_username()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->username());
|
|
}
|
|
|
|
}
|
|
// repeated string groups = 2;
|
|
total_size += 1 * this->groups_size();
|
|
for (int i = 0; i < this->groups_size(); i++) {
|
|
total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->groups(i));
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void UserCredentials::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const UserCredentials* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const UserCredentials*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void UserCredentials::MergeFrom(const UserCredentials& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
groups_.MergeFrom(from.groups_);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_username()) {
|
|
set_username(from.username());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void UserCredentials::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void UserCredentials::CopyFrom(const UserCredentials& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool UserCredentials::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void UserCredentials::Swap(UserCredentials* other) {
|
|
if (other != this) {
|
|
std::swap(username_, other->username_);
|
|
groups_.Swap(&other->groups_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata UserCredentials::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = UserCredentials_descriptor_;
|
|
metadata.reflection = UserCredentials_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int AuthPassword::kPasswordFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
AuthPassword::AuthPassword()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void AuthPassword::InitAsDefaultInstance() {
|
|
}
|
|
|
|
AuthPassword::AuthPassword(const AuthPassword& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void AuthPassword::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
AuthPassword::~AuthPassword() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void AuthPassword::SharedDtor() {
|
|
if (password_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete password_;
|
|
}
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void AuthPassword::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* AuthPassword::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return AuthPassword_descriptor_;
|
|
}
|
|
|
|
const AuthPassword& AuthPassword::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
AuthPassword* AuthPassword::default_instance_ = NULL;
|
|
|
|
AuthPassword* AuthPassword::New() const {
|
|
return new AuthPassword;
|
|
}
|
|
|
|
void AuthPassword::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (has_password()) {
|
|
if (password_ != &::google::protobuf::internal::kEmptyString) {
|
|
password_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool AuthPassword::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required string password = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_password()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->password().data(), this->password().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void AuthPassword::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required string password = 1;
|
|
if (has_password()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->password().data(), this->password().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
1, this->password(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* AuthPassword::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required string password = 1;
|
|
if (has_password()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->password().data(), this->password().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
1, this->password(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int AuthPassword::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required string password = 1;
|
|
if (has_password()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->password());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void AuthPassword::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const AuthPassword* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const AuthPassword*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void AuthPassword::MergeFrom(const AuthPassword& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_password()) {
|
|
set_password(from.password());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void AuthPassword::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void AuthPassword::CopyFrom(const AuthPassword& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool AuthPassword::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void AuthPassword::Swap(AuthPassword* other) {
|
|
if (other != this) {
|
|
std::swap(password_, other->password_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata AuthPassword::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = AuthPassword_descriptor_;
|
|
metadata.reflection = AuthPassword_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int Auth::kAuthTypeFieldNumber;
|
|
const int Auth::kAuthPasswdFieldNumber;
|
|
const int Auth::kAuthDataFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
Auth::Auth()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void Auth::InitAsDefaultInstance() {
|
|
auth_passwd_ = const_cast< ::xtreemfs::pbrpc::AuthPassword*>(&::xtreemfs::pbrpc::AuthPassword::default_instance());
|
|
}
|
|
|
|
Auth::Auth(const Auth& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void Auth::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
auth_type_ = 0;
|
|
auth_passwd_ = NULL;
|
|
auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
Auth::~Auth() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void Auth::SharedDtor() {
|
|
if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete auth_data_;
|
|
}
|
|
if (this != default_instance_) {
|
|
delete auth_passwd_;
|
|
}
|
|
}
|
|
|
|
void Auth::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* Auth::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return Auth_descriptor_;
|
|
}
|
|
|
|
const Auth& Auth::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
Auth* Auth::default_instance_ = NULL;
|
|
|
|
Auth* Auth::New() const {
|
|
return new Auth;
|
|
}
|
|
|
|
void Auth::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
auth_type_ = 0;
|
|
if (has_auth_passwd()) {
|
|
if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear();
|
|
}
|
|
if (has_auth_data()) {
|
|
if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
|
|
auth_data_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool Auth::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::xtreemfs::pbrpc::AuthType_IsValid(value)) {
|
|
set_auth_type(static_cast< ::xtreemfs::pbrpc::AuthType >(value));
|
|
} else {
|
|
mutable_unknown_fields()->AddVarint(1, value);
|
|
}
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_auth_data;
|
|
break;
|
|
}
|
|
|
|
// optional bytes auth_data = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_auth_data:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
|
|
input, this->mutable_auth_data()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_auth_passwd;
|
|
break;
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_auth_passwd:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_auth_passwd()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void Auth::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
|
|
if (has_auth_type()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
1, this->auth_type(), output);
|
|
}
|
|
|
|
// optional bytes auth_data = 2;
|
|
if (has_auth_data()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBytes(
|
|
2, this->auth_data(), output);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
|
|
if (has_auth_passwd()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
3, this->auth_passwd(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* Auth::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
|
|
if (has_auth_type()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->auth_type(), target);
|
|
}
|
|
|
|
// optional bytes auth_data = 2;
|
|
if (has_auth_data()) {
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
|
|
2, this->auth_data(), target);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
|
|
if (has_auth_passwd()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
3, this->auth_passwd(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int Auth::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required .xtreemfs.pbrpc.AuthType auth_type = 1;
|
|
if (has_auth_type()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->auth_type());
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
|
|
if (has_auth_passwd()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->auth_passwd());
|
|
}
|
|
|
|
// optional bytes auth_data = 2;
|
|
if (has_auth_data()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->auth_data());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void Auth::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const Auth* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const Auth*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void Auth::MergeFrom(const Auth& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_auth_type()) {
|
|
set_auth_type(from.auth_type());
|
|
}
|
|
if (from.has_auth_passwd()) {
|
|
mutable_auth_passwd()->::xtreemfs::pbrpc::AuthPassword::MergeFrom(from.auth_passwd());
|
|
}
|
|
if (from.has_auth_data()) {
|
|
set_auth_data(from.auth_data());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void Auth::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void Auth::CopyFrom(const Auth& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool Auth::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
if (has_auth_passwd()) {
|
|
if (!this->auth_passwd().IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Auth::Swap(Auth* other) {
|
|
if (other != this) {
|
|
std::swap(auth_type_, other->auth_type_);
|
|
std::swap(auth_passwd_, other->auth_passwd_);
|
|
std::swap(auth_data_, other->auth_data_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata Auth::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = Auth_descriptor_;
|
|
metadata.reflection = Auth_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int RPCHeader_RequestHeader::kInterfaceIdFieldNumber;
|
|
const int RPCHeader_RequestHeader::kProcIdFieldNumber;
|
|
const int RPCHeader_RequestHeader::kUserCredsFieldNumber;
|
|
const int RPCHeader_RequestHeader::kAuthDataFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
RPCHeader_RequestHeader::RPCHeader_RequestHeader()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::InitAsDefaultInstance() {
|
|
user_creds_ = const_cast< ::xtreemfs::pbrpc::UserCredentials*>(&::xtreemfs::pbrpc::UserCredentials::default_instance());
|
|
auth_data_ = const_cast< ::xtreemfs::pbrpc::Auth*>(&::xtreemfs::pbrpc::Auth::default_instance());
|
|
}
|
|
|
|
RPCHeader_RequestHeader::RPCHeader_RequestHeader(const RPCHeader_RequestHeader& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
interface_id_ = 0u;
|
|
proc_id_ = 0u;
|
|
user_creds_ = NULL;
|
|
auth_data_ = NULL;
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
RPCHeader_RequestHeader::~RPCHeader_RequestHeader() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::SharedDtor() {
|
|
if (this != default_instance_) {
|
|
delete user_creds_;
|
|
delete auth_data_;
|
|
}
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* RPCHeader_RequestHeader::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return RPCHeader_RequestHeader_descriptor_;
|
|
}
|
|
|
|
const RPCHeader_RequestHeader& RPCHeader_RequestHeader::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
RPCHeader_RequestHeader* RPCHeader_RequestHeader::default_instance_ = NULL;
|
|
|
|
RPCHeader_RequestHeader* RPCHeader_RequestHeader::New() const {
|
|
return new RPCHeader_RequestHeader;
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
interface_id_ = 0u;
|
|
proc_id_ = 0u;
|
|
if (has_user_creds()) {
|
|
if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear();
|
|
}
|
|
if (has_auth_data()) {
|
|
if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear();
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required fixed32 interface_id = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
|
|
input, &interface_id_)));
|
|
set_has_interface_id();
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(21)) goto parse_proc_id;
|
|
break;
|
|
}
|
|
|
|
// required fixed32 proc_id = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
|
|
parse_proc_id:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
|
|
input, &proc_id_)));
|
|
set_has_proc_id();
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_user_creds;
|
|
break;
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_user_creds:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_user_creds()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_auth_data;
|
|
break;
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.Auth auth_data = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_auth_data:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_auth_data()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required fixed32 interface_id = 1;
|
|
if (has_interface_id()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->interface_id(), output);
|
|
}
|
|
|
|
// required fixed32 proc_id = 2;
|
|
if (has_proc_id()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->proc_id(), output);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
|
|
if (has_user_creds()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
3, this->user_creds(), output);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.Auth auth_data = 4;
|
|
if (has_auth_data()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
4, this->auth_data(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* RPCHeader_RequestHeader::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required fixed32 interface_id = 1;
|
|
if (has_interface_id()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->interface_id(), target);
|
|
}
|
|
|
|
// required fixed32 proc_id = 2;
|
|
if (has_proc_id()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->proc_id(), target);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
|
|
if (has_user_creds()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
3, this->user_creds(), target);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.Auth auth_data = 4;
|
|
if (has_auth_data()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
4, this->auth_data(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int RPCHeader_RequestHeader::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required fixed32 interface_id = 1;
|
|
if (has_interface_id()) {
|
|
total_size += 1 + 4;
|
|
}
|
|
|
|
// required fixed32 proc_id = 2;
|
|
if (has_proc_id()) {
|
|
total_size += 1 + 4;
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
|
|
if (has_user_creds()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->user_creds());
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.Auth auth_data = 4;
|
|
if (has_auth_data()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->auth_data());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const RPCHeader_RequestHeader* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader_RequestHeader*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::MergeFrom(const RPCHeader_RequestHeader& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_interface_id()) {
|
|
set_interface_id(from.interface_id());
|
|
}
|
|
if (from.has_proc_id()) {
|
|
set_proc_id(from.proc_id());
|
|
}
|
|
if (from.has_user_creds()) {
|
|
mutable_user_creds()->::xtreemfs::pbrpc::UserCredentials::MergeFrom(from.user_creds());
|
|
}
|
|
if (from.has_auth_data()) {
|
|
mutable_auth_data()->::xtreemfs::pbrpc::Auth::MergeFrom(from.auth_data());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::CopyFrom(const RPCHeader_RequestHeader& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool RPCHeader_RequestHeader::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
|
|
|
|
if (has_user_creds()) {
|
|
if (!this->user_creds().IsInitialized()) return false;
|
|
}
|
|
if (has_auth_data()) {
|
|
if (!this->auth_data().IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RPCHeader_RequestHeader::Swap(RPCHeader_RequestHeader* other) {
|
|
if (other != this) {
|
|
std::swap(interface_id_, other->interface_id_);
|
|
std::swap(proc_id_, other->proc_id_);
|
|
std::swap(user_creds_, other->user_creds_);
|
|
std::swap(auth_data_, other->auth_data_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata RPCHeader_RequestHeader::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = RPCHeader_RequestHeader_descriptor_;
|
|
metadata.reflection = RPCHeader_RequestHeader_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
#ifndef _MSC_VER
|
|
const int RPCHeader_ErrorResponse::kErrorTypeFieldNumber;
|
|
const int RPCHeader_ErrorResponse::kPosixErrnoFieldNumber;
|
|
const int RPCHeader_ErrorResponse::kErrorMessageFieldNumber;
|
|
const int RPCHeader_ErrorResponse::kDebugInfoFieldNumber;
|
|
const int RPCHeader_ErrorResponse::kRedirectToServerUuidFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
RPCHeader_ErrorResponse::RPCHeader_ErrorResponse()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::InitAsDefaultInstance() {
|
|
}
|
|
|
|
RPCHeader_ErrorResponse::RPCHeader_ErrorResponse(const RPCHeader_ErrorResponse& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
error_type_ = 1;
|
|
posix_errno_ = 9999;
|
|
error_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
redirect_to_server_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
RPCHeader_ErrorResponse::~RPCHeader_ErrorResponse() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::SharedDtor() {
|
|
if (error_message_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete error_message_;
|
|
}
|
|
if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete debug_info_;
|
|
}
|
|
if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
|
|
delete redirect_to_server_uuid_;
|
|
}
|
|
if (this != default_instance_) {
|
|
}
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return RPCHeader_ErrorResponse_descriptor_;
|
|
}
|
|
|
|
const RPCHeader_ErrorResponse& RPCHeader_ErrorResponse::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::default_instance_ = NULL;
|
|
|
|
RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::New() const {
|
|
return new RPCHeader_ErrorResponse;
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
error_type_ = 1;
|
|
posix_errno_ = 9999;
|
|
if (has_error_message()) {
|
|
if (error_message_ != &::google::protobuf::internal::kEmptyString) {
|
|
error_message_->clear();
|
|
}
|
|
}
|
|
if (has_debug_info()) {
|
|
if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
|
|
debug_info_->clear();
|
|
}
|
|
}
|
|
if (has_redirect_to_server_uuid()) {
|
|
if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
|
|
redirect_to_server_uuid_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::xtreemfs::pbrpc::ErrorType_IsValid(value)) {
|
|
set_error_type(static_cast< ::xtreemfs::pbrpc::ErrorType >(value));
|
|
} else {
|
|
mutable_unknown_fields()->AddVarint(1, value);
|
|
}
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_posix_errno;
|
|
break;
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_posix_errno:
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::xtreemfs::pbrpc::POSIXErrno_IsValid(value)) {
|
|
set_posix_errno(static_cast< ::xtreemfs::pbrpc::POSIXErrno >(value));
|
|
} else {
|
|
mutable_unknown_fields()->AddVarint(2, value);
|
|
}
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_error_message;
|
|
break;
|
|
}
|
|
|
|
// optional string error_message = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_error_message:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_error_message()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->error_message().data(), this->error_message().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_debug_info;
|
|
break;
|
|
}
|
|
|
|
// optional string debug_info = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_debug_info:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_debug_info()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_info().data(), this->debug_info().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_redirect_to_server_uuid;
|
|
break;
|
|
}
|
|
|
|
// optional string redirect_to_server_uuid = 5;
|
|
case 5: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_redirect_to_server_uuid:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_redirect_to_server_uuid()));
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
|
|
::google::protobuf::internal::WireFormat::PARSE);
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
|
|
if (has_error_type()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
1, this->error_type(), output);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
|
|
if (has_posix_errno()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
2, this->posix_errno(), output);
|
|
}
|
|
|
|
// optional string error_message = 3;
|
|
if (has_error_message()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->error_message().data(), this->error_message().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
3, this->error_message(), output);
|
|
}
|
|
|
|
// optional string debug_info = 4;
|
|
if (has_debug_info()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_info().data(), this->debug_info().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
4, this->debug_info(), output);
|
|
}
|
|
|
|
// optional string redirect_to_server_uuid = 5;
|
|
if (has_redirect_to_server_uuid()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
::google::protobuf::internal::WireFormatLite::WriteString(
|
|
5, this->redirect_to_server_uuid(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* RPCHeader_ErrorResponse::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
|
|
if (has_error_type()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->error_type(), target);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
|
|
if (has_posix_errno()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->posix_errno(), target);
|
|
}
|
|
|
|
// optional string error_message = 3;
|
|
if (has_error_message()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->error_message().data(), this->error_message().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
3, this->error_message(), target);
|
|
}
|
|
|
|
// optional string debug_info = 4;
|
|
if (has_debug_info()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->debug_info().data(), this->debug_info().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
4, this->debug_info(), target);
|
|
}
|
|
|
|
// optional string redirect_to_server_uuid = 5;
|
|
if (has_redirect_to_server_uuid()) {
|
|
::google::protobuf::internal::WireFormat::VerifyUTF8String(
|
|
this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
|
|
::google::protobuf::internal::WireFormat::SERIALIZE);
|
|
target =
|
|
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
|
|
5, this->redirect_to_server_uuid(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int RPCHeader_ErrorResponse::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required .xtreemfs.pbrpc.ErrorType error_type = 1;
|
|
if (has_error_type()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
|
|
if (has_posix_errno()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->posix_errno());
|
|
}
|
|
|
|
// optional string error_message = 3;
|
|
if (has_error_message()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->error_message());
|
|
}
|
|
|
|
// optional string debug_info = 4;
|
|
if (has_debug_info()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->debug_info());
|
|
}
|
|
|
|
// optional string redirect_to_server_uuid = 5;
|
|
if (has_redirect_to_server_uuid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->redirect_to_server_uuid());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const RPCHeader_ErrorResponse* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader_ErrorResponse*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::MergeFrom(const RPCHeader_ErrorResponse& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_error_type()) {
|
|
set_error_type(from.error_type());
|
|
}
|
|
if (from.has_posix_errno()) {
|
|
set_posix_errno(from.posix_errno());
|
|
}
|
|
if (from.has_error_message()) {
|
|
set_error_message(from.error_message());
|
|
}
|
|
if (from.has_debug_info()) {
|
|
set_debug_info(from.debug_info());
|
|
}
|
|
if (from.has_redirect_to_server_uuid()) {
|
|
set_redirect_to_server_uuid(from.redirect_to_server_uuid());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::CopyFrom(const RPCHeader_ErrorResponse& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool RPCHeader_ErrorResponse::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void RPCHeader_ErrorResponse::Swap(RPCHeader_ErrorResponse* other) {
|
|
if (other != this) {
|
|
std::swap(error_type_, other->error_type_);
|
|
std::swap(posix_errno_, other->posix_errno_);
|
|
std::swap(error_message_, other->error_message_);
|
|
std::swap(debug_info_, other->debug_info_);
|
|
std::swap(redirect_to_server_uuid_, other->redirect_to_server_uuid_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata RPCHeader_ErrorResponse::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = RPCHeader_ErrorResponse_descriptor_;
|
|
metadata.reflection = RPCHeader_ErrorResponse_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
#ifndef _MSC_VER
|
|
const int RPCHeader::kCallIdFieldNumber;
|
|
const int RPCHeader::kMessageTypeFieldNumber;
|
|
const int RPCHeader::kRequestHeaderFieldNumber;
|
|
const int RPCHeader::kErrorResponseFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
RPCHeader::RPCHeader()
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
}
|
|
|
|
void RPCHeader::InitAsDefaultInstance() {
|
|
request_header_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_RequestHeader*>(&::xtreemfs::pbrpc::RPCHeader_RequestHeader::default_instance());
|
|
error_response_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_ErrorResponse*>(&::xtreemfs::pbrpc::RPCHeader_ErrorResponse::default_instance());
|
|
}
|
|
|
|
RPCHeader::RPCHeader(const RPCHeader& from)
|
|
: ::google::protobuf::Message() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
call_id_ = 0u;
|
|
message_type_ = 0;
|
|
request_header_ = NULL;
|
|
error_response_ = NULL;
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
RPCHeader::~RPCHeader() {
|
|
SharedDtor();
|
|
}
|
|
|
|
void RPCHeader::SharedDtor() {
|
|
if (this != default_instance_) {
|
|
delete request_header_;
|
|
delete error_response_;
|
|
}
|
|
}
|
|
|
|
void RPCHeader::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ::google::protobuf::Descriptor* RPCHeader::descriptor() {
|
|
protobuf_AssignDescriptorsOnce();
|
|
return RPCHeader_descriptor_;
|
|
}
|
|
|
|
const RPCHeader& RPCHeader::default_instance() {
|
|
if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
|
|
return *default_instance_;
|
|
}
|
|
|
|
RPCHeader* RPCHeader::default_instance_ = NULL;
|
|
|
|
RPCHeader* RPCHeader::New() const {
|
|
return new RPCHeader;
|
|
}
|
|
|
|
void RPCHeader::Clear() {
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
call_id_ = 0u;
|
|
message_type_ = 0;
|
|
if (has_request_header()) {
|
|
if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear();
|
|
}
|
|
if (has_error_response()) {
|
|
if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear();
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->Clear();
|
|
}
|
|
|
|
bool RPCHeader::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
|
|
::google::protobuf::uint32 tag;
|
|
while ((tag = input->ReadTag()) != 0) {
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required fixed32 call_id = 1;
|
|
case 1: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
|
|
input, &call_id_)));
|
|
set_has_call_id();
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_message_type;
|
|
break;
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.MessageType message_type = 2;
|
|
case 2: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
|
|
parse_message_type:
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::xtreemfs::pbrpc::MessageType_IsValid(value)) {
|
|
set_message_type(static_cast< ::xtreemfs::pbrpc::MessageType >(value));
|
|
} else {
|
|
mutable_unknown_fields()->AddVarint(2, value);
|
|
}
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_request_header;
|
|
break;
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
|
|
case 3: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_request_header:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_request_header()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_error_response;
|
|
break;
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
|
|
case 4: {
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
|
|
parse_error_response:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_error_response()));
|
|
} else {
|
|
goto handle_uninterpreted;
|
|
}
|
|
if (input->ExpectAtEnd()) return true;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_uninterpreted:
|
|
if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
return true;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormat::SkipField(
|
|
input, tag, mutable_unknown_fields()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
#undef DO_
|
|
}
|
|
|
|
void RPCHeader::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// required fixed32 call_id = 1;
|
|
if (has_call_id()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->call_id(), output);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.MessageType message_type = 2;
|
|
if (has_message_type()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
2, this->message_type(), output);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
|
|
if (has_request_header()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
3, this->request_header(), output);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
|
|
if (has_error_response()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
|
|
4, this->error_response(), output);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
|
|
unknown_fields(), output);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::uint8* RPCHeader::SerializeWithCachedSizesToArray(
|
|
::google::protobuf::uint8* target) const {
|
|
// required fixed32 call_id = 1;
|
|
if (has_call_id()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->call_id(), target);
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.MessageType message_type = 2;
|
|
if (has_message_type()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->message_type(), target);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
|
|
if (has_request_header()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
3, this->request_header(), target);
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
|
|
if (has_error_response()) {
|
|
target = ::google::protobuf::internal::WireFormatLite::
|
|
WriteMessageNoVirtualToArray(
|
|
4, this->error_response(), target);
|
|
}
|
|
|
|
if (!unknown_fields().empty()) {
|
|
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
|
|
unknown_fields(), target);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
int RPCHeader::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required fixed32 call_id = 1;
|
|
if (has_call_id()) {
|
|
total_size += 1 + 4;
|
|
}
|
|
|
|
// required .xtreemfs.pbrpc.MessageType message_type = 2;
|
|
if (has_message_type()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->message_type());
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
|
|
if (has_request_header()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->request_header());
|
|
}
|
|
|
|
// optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
|
|
if (has_error_response()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->error_response());
|
|
}
|
|
|
|
}
|
|
if (!unknown_fields().empty()) {
|
|
total_size +=
|
|
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
|
|
unknown_fields());
|
|
}
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void RPCHeader::MergeFrom(const ::google::protobuf::Message& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
const RPCHeader* source =
|
|
::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader*>(
|
|
&from);
|
|
if (source == NULL) {
|
|
::google::protobuf::internal::ReflectionOps::Merge(from, this);
|
|
} else {
|
|
MergeFrom(*source);
|
|
}
|
|
}
|
|
|
|
void RPCHeader::MergeFrom(const RPCHeader& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_call_id()) {
|
|
set_call_id(from.call_id());
|
|
}
|
|
if (from.has_message_type()) {
|
|
set_message_type(from.message_type());
|
|
}
|
|
if (from.has_request_header()) {
|
|
mutable_request_header()->::xtreemfs::pbrpc::RPCHeader_RequestHeader::MergeFrom(from.request_header());
|
|
}
|
|
if (from.has_error_response()) {
|
|
mutable_error_response()->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::MergeFrom(from.error_response());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->MergeFrom(from.unknown_fields());
|
|
}
|
|
|
|
void RPCHeader::CopyFrom(const ::google::protobuf::Message& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
void RPCHeader::CopyFrom(const RPCHeader& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool RPCHeader::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
|
|
|
|
if (has_request_header()) {
|
|
if (!this->request_header().IsInitialized()) return false;
|
|
}
|
|
if (has_error_response()) {
|
|
if (!this->error_response().IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RPCHeader::Swap(RPCHeader* other) {
|
|
if (other != this) {
|
|
std::swap(call_id_, other->call_id_);
|
|
std::swap(message_type_, other->message_type_);
|
|
std::swap(request_header_, other->request_header_);
|
|
std::swap(error_response_, other->error_response_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.Swap(&other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::google::protobuf::Metadata RPCHeader::GetMetadata() const {
|
|
protobuf_AssignDescriptorsOnce();
|
|
::google::protobuf::Metadata metadata;
|
|
metadata.descriptor = RPCHeader_descriptor_;
|
|
metadata.reflection = RPCHeader_reflection_;
|
|
return metadata;
|
|
}
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace pbrpc
|
|
} // namespace xtreemfs
|
|
|
|
// @@protoc_insertion_point(global_scope)
|