diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h --- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h +++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h @@ -35,107 +35,113 @@ class StubInterface { public: virtual ~StubInterface() {} - std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { - return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response)); + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context)); } - std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq)); } - virtual ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>>(SendLogRaw(context, response)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag)); } - virtual ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> PullBackupKey(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(PullBackupKeyRaw(context)); } - std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) { - return std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, cq)); } - std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(PullCompactionRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, cq)); } class async_interface { public: virtual ~async_interface() {} - virtual void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) = 0; - virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function) = 0; - virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function) = 0; - virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; - virtual void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) = 0; + virtual void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) = 0; + virtual void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) = 0; + virtual void PullBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* reactor) = 0; + virtual void PullCompaction(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } class async_interface* experimental_async() { return async(); } private: - virtual ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0; - virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0; - virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) = 0; - virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; - virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* PullBackupKeyRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); - std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { - return std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response)); + std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq)); } - std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq)); + std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>>(SendLogRaw(context, response)); } - ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq)); } - ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> PullBackupKey(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(PullBackupKeyRaw(context)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, cq, tag)); } - std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) { - return std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, cq)); } - std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) { - return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag)); + std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(PullCompactionRaw(context)); } - std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, cq)); } class async final : public StubInterface::async_interface { public: - void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) override; - void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function) override; - void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; - void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function) override; - void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) override; - void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) override; + void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) override; + void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) override; + void PullBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* reactor) override; + void PullCompaction(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } @@ -147,17 +153,19 @@ private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class async async_stub_{this}; - ::grpc::ClientWriter< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override; - ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override; - ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientReader< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) override; - ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; - ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) override; - const ::grpc::internal::RpcMethod rpcmethod_ResetKey_; + ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override; + ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* PullBackupKeyRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_CreateNewBackup_; const ::grpc::internal::RpcMethod rpcmethod_SendLog_; const ::grpc::internal::RpcMethod rpcmethod_PullBackupKey_; const ::grpc::internal::RpcMethod rpcmethod_PullCompaction_; @@ -168,29 +176,29 @@ public: Service(); virtual ~Service(); - virtual ::grpc::Status ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response); - virtual ::grpc::Status SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response); - virtual ::grpc::Status PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response); - virtual ::grpc::Status PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer); + virtual ::grpc::Status CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream); + virtual ::grpc::Status SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response); + virtual ::grpc::Status PullBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* stream); + virtual ::grpc::Status PullCompaction(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* stream); }; template - class WithAsyncMethod_ResetKey : public BaseClass { + class WithAsyncMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_ResetKey() { + WithAsyncMethod_CreateNewBackup() { ::grpc::Service::MarkMethodAsync(0); } - ~WithAsyncMethod_ResetKey() override { + ~WithAsyncMethod_CreateNewBackup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::ResetKeyRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag); + void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag); } }; template @@ -205,12 +213,12 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestSendLog(::grpc::ServerContext* context, ::backup::SendLogRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::SendLogRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag); } }; template @@ -225,12 +233,12 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { + ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPullBackupKey(::grpc::ServerContext* context, ::backup::PullBackupKeyRequest* request, ::grpc::ServerAsyncResponseWriter< ::backup::PullBackupKeyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag); } }; template @@ -245,36 +253,37 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { + ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPullCompaction(::grpc::ServerContext* context, ::backup::PullCompactionRequest* request, ::grpc::ServerAsyncWriter< ::backup::PullCompactionResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag); + void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_ResetKey > > > AsyncService; + typedef WithAsyncMethod_CreateNewBackup > > > AsyncService; template - class WithCallbackMethod_ResetKey : public BaseClass { + class WithCallbackMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithCallbackMethod_ResetKey() { + WithCallbackMethod_CreateNewBackup() { ::grpc::Service::MarkMethodCallback(0, - new ::grpc::internal::CallbackClientStreamingHandler< ::backup::ResetKeyRequest, ::google::protobuf::Empty>( + new ::grpc::internal::CallbackBidiHandler< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>( [this]( - ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->ResetKey(context, response); })); + ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); })); } - ~WithCallbackMethod_ResetKey() override { + ~WithCallbackMethod_CreateNewBackup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerReadReactor< ::backup::ResetKeyRequest>* ResetKey( - ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + virtual ::grpc::ServerBidiReactor< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackup( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; template class WithCallbackMethod_SendLog : public BaseClass { @@ -283,25 +292,20 @@ public: WithCallbackMethod_SendLog() { ::grpc::Service::MarkMethodCallback(1, - new ::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>( + new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>( [this]( - ::grpc::CallbackServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) { return this->SendLog(context, request, response); }));} - void SetMessageAllocatorFor_SendLog( - ::grpc::MessageAllocator< ::backup::SendLogRequest, ::google::protobuf::Empty>* allocator) { - ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); - static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>*>(handler) - ->SetMessageAllocator(allocator); + ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->SendLog(context, response); })); } ~WithCallbackMethod_SendLog() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* SendLog( - ::grpc::CallbackServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + virtual ::grpc::ServerReadReactor< ::backup::SendLogRequest>* SendLog( + ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } }; template class WithCallbackMethod_PullBackupKey : public BaseClass { @@ -310,25 +314,21 @@ public: WithCallbackMethod_PullBackupKey() { ::grpc::Service::MarkMethodCallback(2, - new ::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>( + new ::grpc::internal::CallbackBidiHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>( [this]( - ::grpc::CallbackServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) { return this->PullBackupKey(context, request, response); }));} - void SetMessageAllocatorFor_PullBackupKey( - ::grpc::MessageAllocator< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* allocator) { - ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); - static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>*>(handler) - ->SetMessageAllocator(allocator); + ::grpc::CallbackServerContext* context) { return this->PullBackupKey(context); })); } ~WithCallbackMethod_PullBackupKey() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { + ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* PullBackupKey( - ::grpc::CallbackServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) { return nullptr; } + virtual ::grpc::ServerBidiReactor< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* PullBackupKey( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; template class WithCallbackMethod_PullCompaction : public BaseClass { @@ -337,36 +337,37 @@ public: WithCallbackMethod_PullCompaction() { ::grpc::Service::MarkMethodCallback(3, - new ::grpc::internal::CallbackServerStreamingHandler< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>( + new ::grpc::internal::CallbackBidiHandler< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>( [this]( - ::grpc::CallbackServerContext* context, const ::backup::PullCompactionRequest* request) { return this->PullCompaction(context, request); })); + ::grpc::CallbackServerContext* context) { return this->PullCompaction(context); })); } ~WithCallbackMethod_PullCompaction() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { + ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerWriteReactor< ::backup::PullCompactionResponse>* PullCompaction( - ::grpc::CallbackServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/) { return nullptr; } + virtual ::grpc::ServerBidiReactor< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* PullCompaction( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; - typedef WithCallbackMethod_ResetKey > > > CallbackService; + typedef WithCallbackMethod_CreateNewBackup > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template - class WithGenericMethod_ResetKey : public BaseClass { + class WithGenericMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_ResetKey() { + WithGenericMethod_CreateNewBackup() { ::grpc::Service::MarkMethodGeneric(0); } - ~WithGenericMethod_ResetKey() override { + ~WithGenericMethod_CreateNewBackup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -383,7 +384,7 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -400,7 +401,7 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { + ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -417,29 +418,29 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { + ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithRawMethod_ResetKey : public BaseClass { + class WithRawMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_ResetKey() { + WithRawMethod_CreateNewBackup() { ::grpc::Service::MarkMethodRaw(0); } - ~WithRawMethod_ResetKey() override { + ~WithRawMethod_CreateNewBackup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag); + void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag); } }; template @@ -454,12 +455,12 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestSendLog(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); + void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag); } }; template @@ -474,12 +475,12 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { + ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); + void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag); } }; template @@ -494,35 +495,36 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { + ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag); + void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag); } }; template - class WithRawCallbackMethod_ResetKey : public BaseClass { + class WithRawCallbackMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawCallbackMethod_ResetKey() { + WithRawCallbackMethod_CreateNewBackup() { ::grpc::Service::MarkMethodRawCallback(0, - new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( - ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->ResetKey(context, response); })); + ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); })); } - ~WithRawCallbackMethod_ResetKey() override { + ~WithRawCallbackMethod_CreateNewBackup() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* ResetKey( - ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* CreateNewBackup( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; template class WithRawCallbackMethod_SendLog : public BaseClass { @@ -531,20 +533,20 @@ public: WithRawCallbackMethod_SendLog() { ::grpc::Service::MarkMethodRawCallback(1, - new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( - ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendLog(context, request, response); })); + ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->SendLog(context, response); })); } ~WithRawCallbackMethod_SendLog() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* SendLog( - ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* SendLog( + ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_PullBackupKey : public BaseClass { @@ -553,20 +555,21 @@ public: WithRawCallbackMethod_PullBackupKey() { ::grpc::Service::MarkMethodRawCallback(2, - new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( - ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PullBackupKey(context, request, response); })); + ::grpc::CallbackServerContext* context) { return this->PullBackupKey(context); })); } ~WithRawCallbackMethod_PullBackupKey() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { + ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual ::grpc::ServerUnaryReactor* PullBackupKey( - ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* PullBackupKey( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; template class WithRawCallbackMethod_PullCompaction : public BaseClass { @@ -575,105 +578,25 @@ public: WithRawCallbackMethod_PullCompaction() { ::grpc::Service::MarkMethodRawCallback(3, - new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( - ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->PullCompaction(context, request); })); + ::grpc::CallbackServerContext* context) { return this->PullCompaction(context); })); } ~WithRawCallbackMethod_PullCompaction() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { - abort(); - return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); - } - virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullCompaction( - ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } - }; - template - class WithStreamedUnaryMethod_SendLog : public BaseClass { - private: - void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} - public: - WithStreamedUnaryMethod_SendLog() { - ::grpc::Service::MarkMethodStreamed(1, - new ::grpc::internal::StreamedUnaryHandler< - ::backup::SendLogRequest, ::google::protobuf::Empty>( - [this](::grpc::ServerContext* context, - ::grpc::ServerUnaryStreamer< - ::backup::SendLogRequest, ::google::protobuf::Empty>* streamer) { - return this->StreamedSendLog(context, - streamer); - })); - } - ~WithStreamedUnaryMethod_SendLog() override { - BaseClassMustBeDerivedFromService(this); - } - // disable regular version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { - abort(); - return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); - } - // replace default version of method with streamed unary - virtual ::grpc::Status StreamedSendLog(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::SendLogRequest,::google::protobuf::Empty>* server_unary_streamer) = 0; - }; - template - class WithStreamedUnaryMethod_PullBackupKey : public BaseClass { - private: - void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} - public: - WithStreamedUnaryMethod_PullBackupKey() { - ::grpc::Service::MarkMethodStreamed(2, - new ::grpc::internal::StreamedUnaryHandler< - ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>( - [this](::grpc::ServerContext* context, - ::grpc::ServerUnaryStreamer< - ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* streamer) { - return this->StreamedPullBackupKey(context, - streamer); - })); - } - ~WithStreamedUnaryMethod_PullBackupKey() override { - BaseClassMustBeDerivedFromService(this); - } - // disable regular version of this method - ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override { - abort(); - return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); - } - // replace default version of method with streamed unary - virtual ::grpc::Status StreamedPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* server_unary_streamer) = 0; - }; - typedef WithStreamedUnaryMethod_SendLog > StreamedUnaryService; - template - class WithSplitStreamingMethod_PullCompaction : public BaseClass { - private: - void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} - public: - WithSplitStreamingMethod_PullCompaction() { - ::grpc::Service::MarkMethodStreamed(3, - new ::grpc::internal::SplitServerStreamingHandler< - ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>( - [this](::grpc::ServerContext* context, - ::grpc::ServerSplitStreamer< - ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* streamer) { - return this->StreamedPullCompaction(context, - streamer); - })); - } - ~WithSplitStreamingMethod_PullCompaction() override { - BaseClassMustBeDerivedFromService(this); - } - // disable regular version of this method - ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override { + ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - // replace default version of method with split streamed - virtual ::grpc::Status StreamedPullCompaction(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* server_split_streamer) = 0; + virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* PullCompaction( + ::grpc::CallbackServerContext* /*context*/) + { return nullptr; } }; - typedef WithSplitStreamingMethod_PullCompaction SplitStreamedService; - typedef WithStreamedUnaryMethod_SendLog > > StreamedService; + typedef Service StreamedUnaryService; + typedef Service SplitStreamedService; + typedef Service StreamedService; }; } // namespace backup diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc @@ -22,7 +22,7 @@ namespace backup { static const char* BackupService_method_names[] = { - "/backup.BackupService/ResetKey", + "/backup.BackupService/CreateNewBackup", "/backup.BackupService/SendLog", "/backup.BackupService/PullBackupKey", "/backup.BackupService/PullCompaction", @@ -35,161 +35,144 @@ } BackupService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) - : channel_(channel), rpcmethod_ResetKey_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) - , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PullBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PullCompaction_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + : channel_(channel), rpcmethod_CreateNewBackup_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) + , rpcmethod_PullBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + , rpcmethod_PullCompaction_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) {} -::grpc::ClientWriter< ::backup::ResetKeyRequest>* BackupService::Stub::ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { - return ::grpc::internal::ClientWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), rpcmethod_ResetKey_, context, response); +::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::CreateNewBackupRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), rpcmethod_CreateNewBackup_, context); } -void BackupService::Stub::async::ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) { - ::grpc::internal::ClientCallbackWriterFactory< ::backup::ResetKeyRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_ResetKey_, context, response, reactor); +void BackupService::Stub::async::CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_CreateNewBackup_, context, reactor); } -::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { - return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, true, tag); +::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, true, tag); } -::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, false, nullptr); +::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, false, nullptr); } -::grpc::Status BackupService::Stub::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) { - return ::grpc::internal::BlockingUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendLog_, context, request, response); +::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return ::grpc::internal::ClientWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), rpcmethod_SendLog_, context, response); } -void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function f) { - ::grpc::internal::CallbackUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, std::move(f)); +void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) { + ::grpc::internal::ClientCallbackWriterFactory< ::backup::SendLogRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, response, reactor); } -void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) { - ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, reactor); +::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, true, tag); } -::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::backup::SendLogRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendLog_, context, request); +::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, false, nullptr); } -::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) { - auto* result = - this->PrepareAsyncSendLogRaw(context, request, cq); - result->StartCall(); - return result; +::grpc::ClientReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* BackupService::Stub::PullBackupKeyRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>::Create(channel_.get(), rpcmethod_PullBackupKey_, context); } -::grpc::Status BackupService::Stub::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) { - return ::grpc::internal::BlockingUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PullBackupKey_, context, request, response); +void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, reactor); } -void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function f) { - ::grpc::internal::CallbackUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, std::move(f)); +::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* BackupService::Stub::AsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_PullBackupKey_, context, true, tag); } -void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) { - ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, reactor); +::grpc::ClientAsyncReaderWriter< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* BackupService::Stub::PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_PullBackupKey_, context, false, nullptr); } -::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PullBackupKey_, context, request); +::grpc::ClientReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* BackupService::Stub::PullCompactionRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>::Create(channel_.get(), rpcmethod_PullCompaction_, context); } -::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) { - auto* result = - this->PrepareAsyncPullBackupKeyRaw(context, request, cq); - result->StartCall(); - return result; +void BackupService::Stub::async::PullCompaction(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* reactor) { + ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullCompaction_, context, reactor); } -::grpc::ClientReader< ::backup::PullCompactionResponse>* BackupService::Stub::PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) { - return ::grpc::internal::ClientReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), rpcmethod_PullCompaction_, context, request); +::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* BackupService::Stub::AsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, true, tag); } -void BackupService::Stub::async::PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) { - ::grpc::internal::ClientCallbackReaderFactory< ::backup::PullCompactionResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullCompaction_, context, request, reactor); -} - -::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) { - return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, true, tag); -} - -::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) { - return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, false, nullptr); +::grpc::ClientAsyncReaderWriter< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* BackupService::Stub::PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, false, nullptr); } BackupService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[0], - ::grpc::internal::RpcMethod::CLIENT_STREAMING, - new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::ResetKeyRequest, ::google::protobuf::Empty>( + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>( [](BackupService::Service* service, ::grpc::ServerContext* ctx, - ::grpc::ServerReader<::backup::ResetKeyRequest>* reader, - ::google::protobuf::Empty* resp) { - return service->ResetKey(ctx, reader, resp); + ::grpc::ServerReaderWriter<::backup::CreateNewBackupResponse, + ::backup::CreateNewBackupRequest>* stream) { + return service->CreateNewBackup(ctx, stream); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[1], - ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty>( [](BackupService::Service* service, ::grpc::ServerContext* ctx, - const ::backup::SendLogRequest* req, + ::grpc::ServerReader<::backup::SendLogRequest>* reader, ::google::protobuf::Empty* resp) { - return service->SendLog(ctx, req, resp); + return service->SendLog(ctx, reader, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[2], - ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>( + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>( [](BackupService::Service* service, ::grpc::ServerContext* ctx, - const ::backup::PullBackupKeyRequest* req, - ::backup::PullBackupKeyResponse* resp) { - return service->PullBackupKey(ctx, req, resp); + ::grpc::ServerReaderWriter<::backup::PullBackupKeyResponse, + ::backup::PullBackupKeyRequest>* stream) { + return service->PullBackupKey(ctx, stream); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[3], - ::grpc::internal::RpcMethod::SERVER_STREAMING, - new ::grpc::internal::ServerStreamingHandler< BackupService::Service, ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>( + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>( [](BackupService::Service* service, ::grpc::ServerContext* ctx, - const ::backup::PullCompactionRequest* req, - ::grpc::ServerWriter<::backup::PullCompactionResponse>* writer) { - return service->PullCompaction(ctx, req, writer); + ::grpc::ServerReaderWriter<::backup::PullCompactionResponse, + ::backup::PullCompactionRequest>* stream) { + return service->PullCompaction(ctx, stream); }, this))); } BackupService::Service::~Service() { } -::grpc::Status BackupService::Service::ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response) { +::grpc::Status BackupService::Service::CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream) { (void) context; - (void) reader; - (void) response; + (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) { +::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response) { (void) context; - (void) request; + (void) reader; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status BackupService::Service::PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) { +::grpc::Status BackupService::Service::PullBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest>* stream) { (void) context; - (void) request; - (void) response; + (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status BackupService::Service::PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer) { +::grpc::Status BackupService::Service::PullCompaction(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullCompactionResponse, ::backup::PullCompactionRequest>* stream) { (void) context; - (void) request; - (void) writer; + (void) stream; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h --- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h +++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h @@ -47,7 +47,7 @@ PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[9] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -56,6 +56,15 @@ extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto; ::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_backup_2eproto_metadata_getter(int index); namespace backup { +class CreateNewBackupRequest; +struct CreateNewBackupRequestDefaultTypeInternal; +extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_; +class CreateNewBackupResponse; +struct CreateNewBackupResponseDefaultTypeInternal; +extern CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_; +class FullAuthenticationRequestData; +struct FullAuthenticationRequestDataDefaultTypeInternal; +extern FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_; class PullBackupKeyRequest; struct PullBackupKeyRequestDefaultTypeInternal; extern PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_; @@ -68,43 +77,46 @@ class PullCompactionResponse; struct PullCompactionResponseDefaultTypeInternal; extern PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_; -class ResetKeyRequest; -struct ResetKeyRequestDefaultTypeInternal; -extern ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_; class SendLogRequest; struct SendLogRequestDefaultTypeInternal; extern SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_; +class SimpleAuthenticationRequestData; +struct SimpleAuthenticationRequestDataDefaultTypeInternal; +extern SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_; } // namespace backup PROTOBUF_NAMESPACE_OPEN +template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*); +template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(Arena*); +template<> ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::FullAuthenticationRequestData>(Arena*); template<> ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage<::backup::PullBackupKeyRequest>(Arena*); template<> ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage<::backup::PullBackupKeyResponse>(Arena*); template<> ::backup::PullCompactionRequest* Arena::CreateMaybeMessage<::backup::PullCompactionRequest>(Arena*); template<> ::backup::PullCompactionResponse* Arena::CreateMaybeMessage<::backup::PullCompactionResponse>(Arena*); -template<> ::backup::ResetKeyRequest* Arena::CreateMaybeMessage<::backup::ResetKeyRequest>(Arena*); template<> ::backup::SendLogRequest* Arena::CreateMaybeMessage<::backup::SendLogRequest>(Arena*); +template<> ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace backup { // =================================================================== -class ResetKeyRequest PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.ResetKeyRequest) */ { +class FullAuthenticationRequestData PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationRequestData) */ { public: - inline ResetKeyRequest() : ResetKeyRequest(nullptr) {} - virtual ~ResetKeyRequest(); - explicit constexpr ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline FullAuthenticationRequestData() : FullAuthenticationRequestData(nullptr) {} + virtual ~FullAuthenticationRequestData(); + explicit constexpr FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - ResetKeyRequest(const ResetKeyRequest& from); - ResetKeyRequest(ResetKeyRequest&& from) noexcept - : ResetKeyRequest() { + FullAuthenticationRequestData(const FullAuthenticationRequestData& from); + FullAuthenticationRequestData(FullAuthenticationRequestData&& from) noexcept + : FullAuthenticationRequestData() { *this = ::std::move(from); } - inline ResetKeyRequest& operator=(const ResetKeyRequest& from) { + inline FullAuthenticationRequestData& operator=(const FullAuthenticationRequestData& from) { CopyFrom(from); return *this; } - inline ResetKeyRequest& operator=(ResetKeyRequest&& from) noexcept { + inline FullAuthenticationRequestData& operator=(FullAuthenticationRequestData&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -122,26 +134,20 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const ResetKeyRequest& default_instance() { + static const FullAuthenticationRequestData& default_instance() { return *internal_default_instance(); } - enum DataCase { - kNewKey = 2, - kCompactionChunk = 3, - DATA_NOT_SET = 0, - }; - - static inline const ResetKeyRequest* internal_default_instance() { - return reinterpret_cast( - &_ResetKeyRequest_default_instance_); + static inline const FullAuthenticationRequestData* internal_default_instance() { + return reinterpret_cast( + &_FullAuthenticationRequestData_default_instance_); } static constexpr int kIndexInFileMessages = 0; - friend void swap(ResetKeyRequest& a, ResetKeyRequest& b) { + friend void swap(FullAuthenticationRequestData& a, FullAuthenticationRequestData& b) { a.Swap(&b); } - inline void Swap(ResetKeyRequest* other) { + inline void Swap(FullAuthenticationRequestData* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -149,7 +155,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ResetKeyRequest* other) { + void UnsafeArenaSwap(FullAuthenticationRequestData* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -157,17 +163,17 @@ // implements Message ---------------------------------------------- - inline ResetKeyRequest* New() const final { - return CreateMaybeMessage(nullptr); + inline FullAuthenticationRequestData* New() const final { + return CreateMaybeMessage(nullptr); } - ResetKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + FullAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ResetKeyRequest& from); - void MergeFrom(const ResetKeyRequest& from); + void CopyFrom(const FullAuthenticationRequestData& from); + void MergeFrom(const FullAuthenticationRequestData& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -181,13 +187,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(ResetKeyRequest* other); + void InternalSwap(FullAuthenticationRequestData* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.ResetKeyRequest"; + return "backup.FullAuthenticationRequestData"; } protected: - explicit ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -206,11 +212,26 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kNewKeyFieldNumber = 2, - kCompactionChunkFieldNumber = 3, + kRequestBytesFieldNumber = 1, + kUserIDFieldNumber = 2, }; - // string userId = 1; + // bytes requestBytes = 1; + void clear_requestbytes(); + const std::string& requestbytes() const; + void set_requestbytes(const std::string& value); + void set_requestbytes(std::string&& value); + void set_requestbytes(const char* value); + void set_requestbytes(const void* value, size_t size); + std::string* mutable_requestbytes(); + std::string* release_requestbytes(); + void set_allocated_requestbytes(std::string* requestbytes); + private: + const std::string& _internal_requestbytes() const; + void _internal_set_requestbytes(const std::string& value); + std::string* _internal_mutable_requestbytes(); + public: + + // string userID = 2; void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -226,92 +247,38 @@ std::string* _internal_mutable_userid(); public: - // bytes newKey = 2; - bool has_newkey() const; - private: - bool _internal_has_newkey() const; - public: - void clear_newkey(); - const std::string& newkey() const; - void set_newkey(const std::string& value); - void set_newkey(std::string&& value); - void set_newkey(const char* value); - void set_newkey(const void* value, size_t size); - std::string* mutable_newkey(); - std::string* release_newkey(); - void set_allocated_newkey(std::string* newkey); - private: - const std::string& _internal_newkey() const; - void _internal_set_newkey(const std::string& value); - std::string* _internal_mutable_newkey(); - public: - - // bytes compactionChunk = 3; - bool has_compactionchunk() const; - private: - bool _internal_has_compactionchunk() const; - public: - void clear_compactionchunk(); - const std::string& compactionchunk() const; - void set_compactionchunk(const std::string& value); - void set_compactionchunk(std::string&& value); - void set_compactionchunk(const char* value); - void set_compactionchunk(const void* value, size_t size); - std::string* mutable_compactionchunk(); - std::string* release_compactionchunk(); - void set_allocated_compactionchunk(std::string* compactionchunk); - private: - const std::string& _internal_compactionchunk() const; - void _internal_set_compactionchunk(const std::string& value); - std::string* _internal_mutable_compactionchunk(); - public: - - void clear_data(); - DataCase data_case() const; - // @@protoc_insertion_point(class_scope:backup.ResetKeyRequest) + // @@protoc_insertion_point(class_scope:backup.FullAuthenticationRequestData) private: class _Internal; - void set_has_newkey(); - void set_has_compactionchunk(); - - inline bool has_data() const; - inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestbytes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; - union DataUnion { - constexpr DataUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newkey_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_; - } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- -class SendLogRequest PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ { +class SimpleAuthenticationRequestData PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SimpleAuthenticationRequestData) */ { public: - inline SendLogRequest() : SendLogRequest(nullptr) {} - virtual ~SendLogRequest(); - explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleAuthenticationRequestData() : SimpleAuthenticationRequestData(nullptr) {} + virtual ~SimpleAuthenticationRequestData(); + explicit constexpr SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - SendLogRequest(const SendLogRequest& from); - SendLogRequest(SendLogRequest&& from) noexcept - : SendLogRequest() { + SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from); + SimpleAuthenticationRequestData(SimpleAuthenticationRequestData&& from) noexcept + : SimpleAuthenticationRequestData() { *this = ::std::move(from); } - inline SendLogRequest& operator=(const SendLogRequest& from) { + inline SimpleAuthenticationRequestData& operator=(const SimpleAuthenticationRequestData& from) { CopyFrom(from); return *this; } - inline SendLogRequest& operator=(SendLogRequest&& from) noexcept { + inline SimpleAuthenticationRequestData& operator=(SimpleAuthenticationRequestData&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -329,20 +296,20 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const SendLogRequest& default_instance() { + static const SimpleAuthenticationRequestData& default_instance() { return *internal_default_instance(); } - static inline const SendLogRequest* internal_default_instance() { - return reinterpret_cast( - &_SendLogRequest_default_instance_); + static inline const SimpleAuthenticationRequestData* internal_default_instance() { + return reinterpret_cast( + &_SimpleAuthenticationRequestData_default_instance_); } static constexpr int kIndexInFileMessages = 1; - friend void swap(SendLogRequest& a, SendLogRequest& b) { + friend void swap(SimpleAuthenticationRequestData& a, SimpleAuthenticationRequestData& b) { a.Swap(&b); } - inline void Swap(SendLogRequest* other) { + inline void Swap(SimpleAuthenticationRequestData* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -350,7 +317,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(SendLogRequest* other) { + void UnsafeArenaSwap(SimpleAuthenticationRequestData* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -358,17 +325,17 @@ // implements Message ---------------------------------------------- - inline SendLogRequest* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleAuthenticationRequestData* New() const final { + return CreateMaybeMessage(nullptr); } - SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SendLogRequest& from); - void MergeFrom(const SendLogRequest& from); + void CopyFrom(const SimpleAuthenticationRequestData& from); + void MergeFrom(const SimpleAuthenticationRequestData& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -382,13 +349,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(SendLogRequest* other); + void InternalSwap(SimpleAuthenticationRequestData* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.SendLogRequest"; + return "backup.SimpleAuthenticationRequestData"; } protected: - explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -407,10 +374,26 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kDataFieldNumber = 2, + kBackupIDFieldNumber = 1, + kUserIDFieldNumber = 2, }; - // string userId = 1; + // string backupID = 1; + void clear_backupid(); + const std::string& backupid() const; + void set_backupid(const std::string& value); + void set_backupid(std::string&& value); + void set_backupid(const char* value); + void set_backupid(const char* value, size_t size); + std::string* mutable_backupid(); + std::string* release_backupid(); + void set_allocated_backupid(std::string* backupid); + private: + const std::string& _internal_backupid() const; + void _internal_set_backupid(const std::string& value); + std::string* _internal_mutable_backupid(); + public: + + // string userID = 2; void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -426,54 +409,38 @@ std::string* _internal_mutable_userid(); public: - // bytes data = 2; - void clear_data(); - const std::string& data() const; - void set_data(const std::string& value); - void set_data(std::string&& value); - void set_data(const char* value); - void set_data(const void* value, size_t size); - std::string* mutable_data(); - std::string* release_data(); - void set_allocated_data(std::string* data); - private: - const std::string& _internal_data() const; - void _internal_set_data(const std::string& value); - std::string* _internal_mutable_data(); - public: - - // @@protoc_insertion_point(class_scope:backup.SendLogRequest) + // @@protoc_insertion_point(class_scope:backup.SimpleAuthenticationRequestData) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- -class PullBackupKeyRequest PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyRequest) */ { +class CreateNewBackupRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupRequest) */ { public: - inline PullBackupKeyRequest() : PullBackupKeyRequest(nullptr) {} - virtual ~PullBackupKeyRequest(); - explicit constexpr PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline CreateNewBackupRequest() : CreateNewBackupRequest(nullptr) {} + virtual ~CreateNewBackupRequest(); + explicit constexpr CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - PullBackupKeyRequest(const PullBackupKeyRequest& from); - PullBackupKeyRequest(PullBackupKeyRequest&& from) noexcept - : PullBackupKeyRequest() { + CreateNewBackupRequest(const CreateNewBackupRequest& from); + CreateNewBackupRequest(CreateNewBackupRequest&& from) noexcept + : CreateNewBackupRequest() { *this = ::std::move(from); } - inline PullBackupKeyRequest& operator=(const PullBackupKeyRequest& from) { + inline CreateNewBackupRequest& operator=(const CreateNewBackupRequest& from) { CopyFrom(from); return *this; } - inline PullBackupKeyRequest& operator=(PullBackupKeyRequest&& from) noexcept { + inline CreateNewBackupRequest& operator=(CreateNewBackupRequest&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -491,20 +458,27 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const PullBackupKeyRequest& default_instance() { + static const CreateNewBackupRequest& default_instance() { return *internal_default_instance(); } - static inline const PullBackupKeyRequest* internal_default_instance() { - return reinterpret_cast( - &_PullBackupKeyRequest_default_instance_); + enum DataCase { + kAuthenticationData = 1, + kNewEncryptedKey = 2, + kNewCompactionChunk = 3, + DATA_NOT_SET = 0, + }; + + static inline const CreateNewBackupRequest* internal_default_instance() { + return reinterpret_cast( + &_CreateNewBackupRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; - friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) { + friend void swap(CreateNewBackupRequest& a, CreateNewBackupRequest& b) { a.Swap(&b); } - inline void Swap(PullBackupKeyRequest* other) { + inline void Swap(CreateNewBackupRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -512,7 +486,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PullBackupKeyRequest* other) { + void UnsafeArenaSwap(CreateNewBackupRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -520,17 +494,17 @@ // implements Message ---------------------------------------------- - inline PullBackupKeyRequest* New() const final { - return CreateMaybeMessage(nullptr); + inline CreateNewBackupRequest* New() const final { + return CreateMaybeMessage(nullptr); } - PullBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CreateNewBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const PullBackupKeyRequest& from); - void MergeFrom(const PullBackupKeyRequest& from); + void CopyFrom(const CreateNewBackupRequest& from); + void MergeFrom(const CreateNewBackupRequest& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -544,13 +518,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(PullBackupKeyRequest* other); + void InternalSwap(CreateNewBackupRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.PullBackupKeyRequest"; + return "backup.CreateNewBackupRequest"; } protected: - explicit PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -569,73 +543,115 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kPakeKeyFieldNumber = 2, + kAuthenticationDataFieldNumber = 1, + kNewEncryptedKeyFieldNumber = 2, + kNewCompactionChunkFieldNumber = 3, }; - // string userId = 1; - void clear_userid(); - const std::string& userid() const; - void set_userid(const std::string& value); - void set_userid(std::string&& value); - void set_userid(const char* value); - void set_userid(const char* value, size_t size); - std::string* mutable_userid(); - std::string* release_userid(); - void set_allocated_userid(std::string* userid); + // .backup.FullAuthenticationRequestData authenticationData = 1; + bool has_authenticationdata() const; private: - const std::string& _internal_userid() const; - void _internal_set_userid(const std::string& value); - std::string* _internal_mutable_userid(); + bool _internal_has_authenticationdata() const; public: + void clear_authenticationdata(); + const ::backup::FullAuthenticationRequestData& authenticationdata() const; + ::backup::FullAuthenticationRequestData* release_authenticationdata(); + ::backup::FullAuthenticationRequestData* mutable_authenticationdata(); + void set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata); + private: + const ::backup::FullAuthenticationRequestData& _internal_authenticationdata() const; + ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationdata(); + public: + void unsafe_arena_set_allocated_authenticationdata( + ::backup::FullAuthenticationRequestData* authenticationdata); + ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationdata(); - // bytes pakeKey = 2; - void clear_pakekey(); - const std::string& pakekey() const; - void set_pakekey(const std::string& value); - void set_pakekey(std::string&& value); - void set_pakekey(const char* value); - void set_pakekey(const void* value, size_t size); - std::string* mutable_pakekey(); - std::string* release_pakekey(); - void set_allocated_pakekey(std::string* pakekey); + // bytes newEncryptedKey = 2; + bool has_newencryptedkey() const; + private: + bool _internal_has_newencryptedkey() const; + public: + void clear_newencryptedkey(); + const std::string& newencryptedkey() const; + void set_newencryptedkey(const std::string& value); + void set_newencryptedkey(std::string&& value); + void set_newencryptedkey(const char* value); + void set_newencryptedkey(const void* value, size_t size); + std::string* mutable_newencryptedkey(); + std::string* release_newencryptedkey(); + void set_allocated_newencryptedkey(std::string* newencryptedkey); private: - const std::string& _internal_pakekey() const; - void _internal_set_pakekey(const std::string& value); - std::string* _internal_mutable_pakekey(); + const std::string& _internal_newencryptedkey() const; + void _internal_set_newencryptedkey(const std::string& value); + std::string* _internal_mutable_newencryptedkey(); public: - // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest) + // bytes newCompactionChunk = 3; + bool has_newcompactionchunk() const; + private: + bool _internal_has_newcompactionchunk() const; + public: + void clear_newcompactionchunk(); + const std::string& newcompactionchunk() const; + void set_newcompactionchunk(const std::string& value); + void set_newcompactionchunk(std::string&& value); + void set_newcompactionchunk(const char* value); + void set_newcompactionchunk(const void* value, size_t size); + std::string* mutable_newcompactionchunk(); + std::string* release_newcompactionchunk(); + void set_allocated_newcompactionchunk(std::string* newcompactionchunk); + private: + const std::string& _internal_newcompactionchunk() const; + void _internal_set_newcompactionchunk(const std::string& value); + std::string* _internal_mutable_newcompactionchunk(); + public: + + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:backup.CreateNewBackupRequest) private: class _Internal; + void set_has_authenticationdata(); + void set_has_newencryptedkey(); + void set_has_newcompactionchunk(); + + inline bool has_data() const; + inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakekey_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::backup::FullAuthenticationRequestData* authenticationdata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newencryptedkey_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionchunk_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- -class PullBackupKeyResponse PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyResponse) */ { +class CreateNewBackupResponse PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupResponse) */ { public: - inline PullBackupKeyResponse() : PullBackupKeyResponse(nullptr) {} - virtual ~PullBackupKeyResponse(); - explicit constexpr PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline CreateNewBackupResponse() : CreateNewBackupResponse(nullptr) {} + virtual ~CreateNewBackupResponse(); + explicit constexpr CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - PullBackupKeyResponse(const PullBackupKeyResponse& from); - PullBackupKeyResponse(PullBackupKeyResponse&& from) noexcept - : PullBackupKeyResponse() { + CreateNewBackupResponse(const CreateNewBackupResponse& from); + CreateNewBackupResponse(CreateNewBackupResponse&& from) noexcept + : CreateNewBackupResponse() { *this = ::std::move(from); } - inline PullBackupKeyResponse& operator=(const PullBackupKeyResponse& from) { + inline CreateNewBackupResponse& operator=(const CreateNewBackupResponse& from) { CopyFrom(from); return *this; } - inline PullBackupKeyResponse& operator=(PullBackupKeyResponse&& from) noexcept { + inline CreateNewBackupResponse& operator=(CreateNewBackupResponse&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -653,20 +669,26 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const PullBackupKeyResponse& default_instance() { + static const CreateNewBackupResponse& default_instance() { return *internal_default_instance(); } - static inline const PullBackupKeyResponse* internal_default_instance() { - return reinterpret_cast( - &_PullBackupKeyResponse_default_instance_); + enum DataCase { + kResponseBytes = 1, + kBackupID = 2, + DATA_NOT_SET = 0, + }; + + static inline const CreateNewBackupResponse* internal_default_instance() { + return reinterpret_cast( + &_CreateNewBackupResponse_default_instance_); } static constexpr int kIndexInFileMessages = 3; - friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) { + friend void swap(CreateNewBackupResponse& a, CreateNewBackupResponse& b) { a.Swap(&b); } - inline void Swap(PullBackupKeyResponse* other) { + inline void Swap(CreateNewBackupResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -674,7 +696,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PullBackupKeyResponse* other) { + void UnsafeArenaSwap(CreateNewBackupResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -682,17 +704,17 @@ // implements Message ---------------------------------------------- - inline PullBackupKeyResponse* New() const final { - return CreateMaybeMessage(nullptr); + inline CreateNewBackupResponse* New() const final { + return CreateMaybeMessage(nullptr); } - PullBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CreateNewBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const PullBackupKeyResponse& from); - void MergeFrom(const PullBackupKeyResponse& from); + void CopyFrom(const CreateNewBackupResponse& from); + void MergeFrom(const CreateNewBackupResponse& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -706,13 +728,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(PullBackupKeyResponse* other); + void InternalSwap(CreateNewBackupResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.PullBackupKeyResponse"; + return "backup.CreateNewBackupResponse"; } protected: - explicit PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -731,55 +753,94 @@ // accessors ------------------------------------------------------- enum : int { - kEncryptedBackupKeyFieldNumber = 1, + kResponseBytesFieldNumber = 1, + kBackupIDFieldNumber = 2, }; - // bytes encryptedBackupKey = 1; - void clear_encryptedbackupkey(); - const std::string& encryptedbackupkey() const; - void set_encryptedbackupkey(const std::string& value); - void set_encryptedbackupkey(std::string&& value); - void set_encryptedbackupkey(const char* value); - void set_encryptedbackupkey(const void* value, size_t size); - std::string* mutable_encryptedbackupkey(); - std::string* release_encryptedbackupkey(); - void set_allocated_encryptedbackupkey(std::string* encryptedbackupkey); + // bytes responseBytes = 1; + bool has_responsebytes() const; private: - const std::string& _internal_encryptedbackupkey() const; - void _internal_set_encryptedbackupkey(const std::string& value); - std::string* _internal_mutable_encryptedbackupkey(); + bool _internal_has_responsebytes() const; + public: + void clear_responsebytes(); + const std::string& responsebytes() const; + void set_responsebytes(const std::string& value); + void set_responsebytes(std::string&& value); + void set_responsebytes(const char* value); + void set_responsebytes(const void* value, size_t size); + std::string* mutable_responsebytes(); + std::string* release_responsebytes(); + void set_allocated_responsebytes(std::string* responsebytes); + private: + const std::string& _internal_responsebytes() const; + void _internal_set_responsebytes(const std::string& value); + std::string* _internal_mutable_responsebytes(); public: - // @@protoc_insertion_point(class_scope:backup.PullBackupKeyResponse) + // string backupID = 2; + bool has_backupid() const; + private: + bool _internal_has_backupid() const; + public: + void clear_backupid(); + const std::string& backupid() const; + void set_backupid(const std::string& value); + void set_backupid(std::string&& value); + void set_backupid(const char* value); + void set_backupid(const char* value, size_t size); + std::string* mutable_backupid(); + std::string* release_backupid(); + void set_allocated_backupid(std::string* backupid); + private: + const std::string& _internal_backupid() const; + void _internal_set_backupid(const std::string& value); + std::string* _internal_mutable_backupid(); + public: + + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:backup.CreateNewBackupResponse) private: class _Internal; + void set_has_responsebytes(); + void set_has_backupid(); + + inline bool has_data() const; + inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryptedbackupkey_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responsebytes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- -class PullCompactionRequest PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionRequest) */ { +class SendLogRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ { public: - inline PullCompactionRequest() : PullCompactionRequest(nullptr) {} - virtual ~PullCompactionRequest(); - explicit constexpr PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SendLogRequest() : SendLogRequest(nullptr) {} + virtual ~SendLogRequest(); + explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - PullCompactionRequest(const PullCompactionRequest& from); - PullCompactionRequest(PullCompactionRequest&& from) noexcept - : PullCompactionRequest() { + SendLogRequest(const SendLogRequest& from); + SendLogRequest(SendLogRequest&& from) noexcept + : SendLogRequest() { *this = ::std::move(from); } - inline PullCompactionRequest& operator=(const PullCompactionRequest& from) { + inline SendLogRequest& operator=(const SendLogRequest& from) { CopyFrom(from); return *this; } - inline PullCompactionRequest& operator=(PullCompactionRequest&& from) noexcept { + inline SendLogRequest& operator=(SendLogRequest&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -797,20 +858,20 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const PullCompactionRequest& default_instance() { + static const SendLogRequest& default_instance() { return *internal_default_instance(); } - static inline const PullCompactionRequest* internal_default_instance() { - return reinterpret_cast( - &_PullCompactionRequest_default_instance_); + static inline const SendLogRequest* internal_default_instance() { + return reinterpret_cast( + &_SendLogRequest_default_instance_); } static constexpr int kIndexInFileMessages = 4; - friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) { + friend void swap(SendLogRequest& a, SendLogRequest& b) { a.Swap(&b); } - inline void Swap(PullCompactionRequest* other) { + inline void Swap(SendLogRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -818,7 +879,7 @@ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PullCompactionRequest* other) { + void UnsafeArenaSwap(SendLogRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -826,17 +887,17 @@ // implements Message ---------------------------------------------- - inline PullCompactionRequest* New() const final { - return CreateMaybeMessage(nullptr); + inline SendLogRequest* New() const final { + return CreateMaybeMessage(nullptr); } - PullCompactionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const PullCompactionRequest& from); - void MergeFrom(const PullCompactionRequest& from); + void CopyFrom(const SendLogRequest& from); + void MergeFrom(const SendLogRequest& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -850,13 +911,13 @@ inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(PullCompactionRequest* other); + void InternalSwap(SendLogRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.PullCompactionRequest"; + return "backup.SendLogRequest"; } protected: - explicit PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -875,41 +936,525 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kMessageFieldNumber = 2, + kLogDataFieldNumber = 2, + kAuthenticationDataFieldNumber = 1, }; - // string userId = 1; - void clear_userid(); - const std::string& userid() const; - void set_userid(const std::string& value); - void set_userid(std::string&& value); - void set_userid(const char* value); - void set_userid(const char* value, size_t size); - std::string* mutable_userid(); - std::string* release_userid(); - void set_allocated_userid(std::string* userid); + // bytes logData = 2; + void clear_logdata(); + const std::string& logdata() const; + void set_logdata(const std::string& value); + void set_logdata(std::string&& value); + void set_logdata(const char* value); + void set_logdata(const void* value, size_t size); + std::string* mutable_logdata(); + std::string* release_logdata(); + void set_allocated_logdata(std::string* logdata); private: - const std::string& _internal_userid() const; - void _internal_set_userid(const std::string& value); - std::string* _internal_mutable_userid(); + const std::string& _internal_logdata() const; + void _internal_set_logdata(const std::string& value); + std::string* _internal_mutable_logdata(); public: - // bytes message = 2; - void clear_message(); - const std::string& message() const; - void set_message(const std::string& value); - void set_message(std::string&& value); - void set_message(const char* value); - void set_message(const void* value, size_t size); - std::string* mutable_message(); - std::string* release_message(); - void set_allocated_message(std::string* message); + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + bool has_authenticationdata() const; private: - const std::string& _internal_message() const; - void _internal_set_message(const std::string& value); - std::string* _internal_mutable_message(); + bool _internal_has_authenticationdata() const; public: - + void clear_authenticationdata(); + const ::backup::SimpleAuthenticationRequestData& authenticationdata() const; + ::backup::SimpleAuthenticationRequestData* release_authenticationdata(); + ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata(); + void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata); + private: + const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const; + ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata(); + public: + void unsafe_arena_set_allocated_authenticationdata( + ::backup::SimpleAuthenticationRequestData* authenticationdata); + ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata(); + + // @@protoc_insertion_point(class_scope:backup.SendLogRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logdata_; + ::backup::SimpleAuthenticationRequestData* authenticationdata_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_backup_2eproto; +}; +// ------------------------------------------------------------------- + +class PullBackupKeyRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyRequest) */ { + public: + inline PullBackupKeyRequest() : PullBackupKeyRequest(nullptr) {} + virtual ~PullBackupKeyRequest(); + explicit constexpr PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PullBackupKeyRequest(const PullBackupKeyRequest& from); + PullBackupKeyRequest(PullBackupKeyRequest&& from) noexcept + : PullBackupKeyRequest() { + *this = ::std::move(from); + } + + inline PullBackupKeyRequest& operator=(const PullBackupKeyRequest& from) { + CopyFrom(from); + return *this; + } + inline PullBackupKeyRequest& operator=(PullBackupKeyRequest&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PullBackupKeyRequest& default_instance() { + return *internal_default_instance(); + } + static inline const PullBackupKeyRequest* internal_default_instance() { + return reinterpret_cast( + &_PullBackupKeyRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) { + a.Swap(&b); + } + inline void Swap(PullBackupKeyRequest* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PullBackupKeyRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PullBackupKeyRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + PullBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PullBackupKeyRequest& from); + void MergeFrom(const PullBackupKeyRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PullBackupKeyRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.PullBackupKeyRequest"; + } + protected: + explicit PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAuthenticationDataFieldNumber = 1, + }; + // .backup.FullAuthenticationRequestData authenticationData = 1; + bool has_authenticationdata() const; + private: + bool _internal_has_authenticationdata() const; + public: + void clear_authenticationdata(); + const ::backup::FullAuthenticationRequestData& authenticationdata() const; + ::backup::FullAuthenticationRequestData* release_authenticationdata(); + ::backup::FullAuthenticationRequestData* mutable_authenticationdata(); + void set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata); + private: + const ::backup::FullAuthenticationRequestData& _internal_authenticationdata() const; + ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationdata(); + public: + void unsafe_arena_set_allocated_authenticationdata( + ::backup::FullAuthenticationRequestData* authenticationdata); + ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationdata(); + + // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::backup::FullAuthenticationRequestData* authenticationdata_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_backup_2eproto; +}; +// ------------------------------------------------------------------- + +class PullBackupKeyResponse PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyResponse) */ { + public: + inline PullBackupKeyResponse() : PullBackupKeyResponse(nullptr) {} + virtual ~PullBackupKeyResponse(); + explicit constexpr PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PullBackupKeyResponse(const PullBackupKeyResponse& from); + PullBackupKeyResponse(PullBackupKeyResponse&& from) noexcept + : PullBackupKeyResponse() { + *this = ::std::move(from); + } + + inline PullBackupKeyResponse& operator=(const PullBackupKeyResponse& from) { + CopyFrom(from); + return *this; + } + inline PullBackupKeyResponse& operator=(PullBackupKeyResponse&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PullBackupKeyResponse& default_instance() { + return *internal_default_instance(); + } + enum DataCase { + kResponseBytes = 1, + kEncryptedBackupIDAndKey = 2, + DATA_NOT_SET = 0, + }; + + static inline const PullBackupKeyResponse* internal_default_instance() { + return reinterpret_cast( + &_PullBackupKeyResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) { + a.Swap(&b); + } + inline void Swap(PullBackupKeyResponse* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PullBackupKeyResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PullBackupKeyResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + PullBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PullBackupKeyResponse& from); + void MergeFrom(const PullBackupKeyResponse& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PullBackupKeyResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.PullBackupKeyResponse"; + } + protected: + explicit PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kResponseBytesFieldNumber = 1, + kEncryptedBackupIDAndKeyFieldNumber = 2, + }; + // bytes responseBytes = 1; + bool has_responsebytes() const; + private: + bool _internal_has_responsebytes() const; + public: + void clear_responsebytes(); + const std::string& responsebytes() const; + void set_responsebytes(const std::string& value); + void set_responsebytes(std::string&& value); + void set_responsebytes(const char* value); + void set_responsebytes(const void* value, size_t size); + std::string* mutable_responsebytes(); + std::string* release_responsebytes(); + void set_allocated_responsebytes(std::string* responsebytes); + private: + const std::string& _internal_responsebytes() const; + void _internal_set_responsebytes(const std::string& value); + std::string* _internal_mutable_responsebytes(); + public: + + // bytes encryptedBackupIDAndKey = 2; + bool has_encryptedbackupidandkey() const; + private: + bool _internal_has_encryptedbackupidandkey() const; + public: + void clear_encryptedbackupidandkey(); + const std::string& encryptedbackupidandkey() const; + void set_encryptedbackupidandkey(const std::string& value); + void set_encryptedbackupidandkey(std::string&& value); + void set_encryptedbackupidandkey(const char* value); + void set_encryptedbackupidandkey(const void* value, size_t size); + std::string* mutable_encryptedbackupidandkey(); + std::string* release_encryptedbackupidandkey(); + void set_allocated_encryptedbackupidandkey(std::string* encryptedbackupidandkey); + private: + const std::string& _internal_encryptedbackupidandkey() const; + void _internal_set_encryptedbackupidandkey(const std::string& value); + std::string* _internal_mutable_encryptedbackupidandkey(); + public: + + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:backup.PullBackupKeyResponse) + private: + class _Internal; + void set_has_responsebytes(); + void set_has_encryptedbackupidandkey(); + + inline bool has_data() const; + inline void clear_has_data(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr responsebytes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryptedbackupidandkey_; + } data_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_backup_2eproto; +}; +// ------------------------------------------------------------------- + +class PullCompactionRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionRequest) */ { + public: + inline PullCompactionRequest() : PullCompactionRequest(nullptr) {} + virtual ~PullCompactionRequest(); + explicit constexpr PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PullCompactionRequest(const PullCompactionRequest& from); + PullCompactionRequest(PullCompactionRequest&& from) noexcept + : PullCompactionRequest() { + *this = ::std::move(from); + } + + inline PullCompactionRequest& operator=(const PullCompactionRequest& from) { + CopyFrom(from); + return *this; + } + inline PullCompactionRequest& operator=(PullCompactionRequest&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const PullCompactionRequest& default_instance() { + return *internal_default_instance(); + } + static inline const PullCompactionRequest* internal_default_instance() { + return reinterpret_cast( + &_PullCompactionRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) { + a.Swap(&b); + } + inline void Swap(PullCompactionRequest* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PullCompactionRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PullCompactionRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + PullCompactionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PullCompactionRequest& from); + void MergeFrom(const PullCompactionRequest& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PullCompactionRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.PullCompactionRequest"; + } + protected: + explicit PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages); + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAuthenticationDataFieldNumber = 1, + }; + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + bool has_authenticationdata() const; + private: + bool _internal_has_authenticationdata() const; + public: + void clear_authenticationdata(); + const ::backup::SimpleAuthenticationRequestData& authenticationdata() const; + ::backup::SimpleAuthenticationRequestData* release_authenticationdata(); + ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata(); + void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata); + private: + const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const; + ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata(); + public: + void unsafe_arena_set_allocated_authenticationdata( + ::backup::SimpleAuthenticationRequestData* authenticationdata); + ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata(); + // @@protoc_insertion_point(class_scope:backup.PullCompactionRequest) private: class _Internal; @@ -917,8 +1462,7 @@ template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_; + ::backup::SimpleAuthenticationRequestData* authenticationdata_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_backup_2eproto; }; @@ -973,7 +1517,7 @@ &_PullCompactionResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 8; friend void swap(PullCompactionResponse& a, PullCompactionResponse& b) { a.Swap(&b); @@ -1120,59 +1664,246 @@ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ -// ResetKeyRequest +// FullAuthenticationRequestData + +// bytes requestBytes = 1; +inline void FullAuthenticationRequestData::clear_requestbytes() { + requestbytes_.ClearToEmpty(); +} +inline const std::string& FullAuthenticationRequestData::requestbytes() const { + // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.requestBytes) + return _internal_requestbytes(); +} +inline void FullAuthenticationRequestData::set_requestbytes(const std::string& value) { + _internal_set_requestbytes(value); + // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.requestBytes) +} +inline std::string* FullAuthenticationRequestData::mutable_requestbytes() { + // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.requestBytes) + return _internal_mutable_requestbytes(); +} +inline const std::string& FullAuthenticationRequestData::_internal_requestbytes() const { + return requestbytes_.Get(); +} +inline void FullAuthenticationRequestData::_internal_set_requestbytes(const std::string& value) { + + requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void FullAuthenticationRequestData::set_requestbytes(std::string&& value) { + + requestbytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.requestBytes) +} +inline void FullAuthenticationRequestData::set_requestbytes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.requestBytes) +} +inline void FullAuthenticationRequestData::set_requestbytes(const void* value, + size_t size) { + + requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.requestBytes) +} +inline std::string* FullAuthenticationRequestData::_internal_mutable_requestbytes() { + + return requestbytes_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FullAuthenticationRequestData::release_requestbytes() { + // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.requestBytes) + return requestbytes_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FullAuthenticationRequestData::set_allocated_requestbytes(std::string* requestbytes) { + if (requestbytes != nullptr) { + + } else { + + } + requestbytes_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), requestbytes, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.requestBytes) +} + +// string userID = 2; +inline void FullAuthenticationRequestData::clear_userid() { + userid_.ClearToEmpty(); +} +inline const std::string& FullAuthenticationRequestData::userid() const { + // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.userID) + return _internal_userid(); +} +inline void FullAuthenticationRequestData::set_userid(const std::string& value) { + _internal_set_userid(value); + // @@protoc_insertion_point(field_set:backup.FullAuthenticationRequestData.userID) +} +inline std::string* FullAuthenticationRequestData::mutable_userid() { + // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.userID) + return _internal_mutable_userid(); +} +inline const std::string& FullAuthenticationRequestData::_internal_userid() const { + return userid_.Get(); +} +inline void FullAuthenticationRequestData::_internal_set_userid(const std::string& value) { + + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void FullAuthenticationRequestData::set_userid(std::string&& value) { + + userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.FullAuthenticationRequestData.userID) +} +inline void FullAuthenticationRequestData::set_userid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.FullAuthenticationRequestData.userID) +} +inline void FullAuthenticationRequestData::set_userid(const char* value, + size_t size) { + + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.FullAuthenticationRequestData.userID) +} +inline std::string* FullAuthenticationRequestData::_internal_mutable_userid() { + + return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FullAuthenticationRequestData::release_userid() { + // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.userID) + return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FullAuthenticationRequestData::set_allocated_userid(std::string* userid) { + if (userid != nullptr) { + + } else { + + } + userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.userID) +} + +// ------------------------------------------------------------------- + +// SimpleAuthenticationRequestData -// string userId = 1; -inline void ResetKeyRequest::clear_userid() { +// string backupID = 1; +inline void SimpleAuthenticationRequestData::clear_backupid() { + backupid_.ClearToEmpty(); +} +inline const std::string& SimpleAuthenticationRequestData::backupid() const { + // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.backupID) + return _internal_backupid(); +} +inline void SimpleAuthenticationRequestData::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.backupID) +} +inline std::string* SimpleAuthenticationRequestData::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.backupID) + return _internal_mutable_backupid(); +} +inline const std::string& SimpleAuthenticationRequestData::_internal_backupid() const { + return backupid_.Get(); +} +inline void SimpleAuthenticationRequestData::_internal_set_backupid(const std::string& value) { + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void SimpleAuthenticationRequestData::set_backupid(std::string&& value) { + + backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.backupID) +} +inline void SimpleAuthenticationRequestData::set_backupid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.backupID) +} +inline void SimpleAuthenticationRequestData::set_backupid(const char* value, + size_t size) { + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.backupID) +} +inline std::string* SimpleAuthenticationRequestData::_internal_mutable_backupid() { + + return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SimpleAuthenticationRequestData::release_backupid() { + // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.backupID) + return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SimpleAuthenticationRequestData::set_allocated_backupid(std::string* backupid) { + if (backupid != nullptr) { + + } else { + + } + backupid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), backupid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.backupID) +} + +// string userID = 2; +inline void SimpleAuthenticationRequestData::clear_userid() { userid_.ClearToEmpty(); } -inline const std::string& ResetKeyRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.userId) +inline const std::string& SimpleAuthenticationRequestData::userid() const { + // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.userID) return _internal_userid(); } -inline void ResetKeyRequest::set_userid(const std::string& value) { +inline void SimpleAuthenticationRequestData::set_userid(const std::string& value) { _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.userId) + // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.userID) } -inline std::string* ResetKeyRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.userId) +inline std::string* SimpleAuthenticationRequestData::mutable_userid() { + // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.userID) return _internal_mutable_userid(); } -inline const std::string& ResetKeyRequest::_internal_userid() const { +inline const std::string& SimpleAuthenticationRequestData::_internal_userid() const { return userid_.Get(); } -inline void ResetKeyRequest::_internal_set_userid(const std::string& value) { +inline void SimpleAuthenticationRequestData::_internal_set_userid(const std::string& value) { userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void ResetKeyRequest::set_userid(std::string&& value) { +inline void SimpleAuthenticationRequestData::set_userid(std::string&& value) { userid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.userId) + // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.userID) } -inline void ResetKeyRequest::set_userid(const char* value) { +inline void SimpleAuthenticationRequestData::set_userid(const char* value) { GOOGLE_DCHECK(value != nullptr); userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.userId) + // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.userID) } -inline void ResetKeyRequest::set_userid(const char* value, +inline void SimpleAuthenticationRequestData::set_userid(const char* value, size_t size) { userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.userId) + // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.userID) } -inline std::string* ResetKeyRequest::_internal_mutable_userid() { +inline std::string* SimpleAuthenticationRequestData::_internal_mutable_userid() { return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* ResetKeyRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.userId) +inline std::string* SimpleAuthenticationRequestData::release_userid() { + // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.userID) return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void ResetKeyRequest::set_allocated_userid(std::string* userid) { +inline void SimpleAuthenticationRequestData::set_allocated_userid(std::string* userid) { if (userid != nullptr) { } else { @@ -1180,679 +1911,1101 @@ } userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.userId) + // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.userID) +} + +// ------------------------------------------------------------------- + +// CreateNewBackupRequest + +// .backup.FullAuthenticationRequestData authenticationData = 1; +inline bool CreateNewBackupRequest::_internal_has_authenticationdata() const { + return data_case() == kAuthenticationData; +} +inline bool CreateNewBackupRequest::has_authenticationdata() const { + return _internal_has_authenticationdata(); +} +inline void CreateNewBackupRequest::set_has_authenticationdata() { + _oneof_case_[0] = kAuthenticationData; +} +inline void CreateNewBackupRequest::clear_authenticationdata() { + if (_internal_has_authenticationdata()) { + if (GetArena() == nullptr) { + delete data_.authenticationdata_; + } + clear_has_data(); + } +} +inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::release_authenticationdata() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationData) + if (_internal_has_authenticationdata()) { + clear_has_data(); + ::backup::FullAuthenticationRequestData* temp = data_.authenticationdata_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.authenticationdata_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::_internal_authenticationdata() const { + return _internal_has_authenticationdata() + ? *data_.authenticationdata_ + : reinterpret_cast< ::backup::FullAuthenticationRequestData&>(::backup::_FullAuthenticationRequestData_default_instance_); +} +inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::authenticationdata() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationData) + return _internal_authenticationdata(); +} +inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::unsafe_arena_release_authenticationdata() { + // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationData) + if (_internal_has_authenticationdata()) { + clear_has_data(); + ::backup::FullAuthenticationRequestData* temp = data_.authenticationdata_; + data_.authenticationdata_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) { + clear_data(); + if (authenticationdata) { + set_has_authenticationdata(); + data_.authenticationdata_ = authenticationdata; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationData) +} +inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::_internal_mutable_authenticationdata() { + if (!_internal_has_authenticationdata()) { + clear_data(); + set_has_authenticationdata(); + data_.authenticationdata_ = CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(GetArena()); + } + return data_.authenticationdata_; +} +inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::mutable_authenticationdata() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationData) + return _internal_mutable_authenticationdata(); +} + +// bytes newEncryptedKey = 2; +inline bool CreateNewBackupRequest::_internal_has_newencryptedkey() const { + return data_case() == kNewEncryptedKey; +} +inline bool CreateNewBackupRequest::has_newencryptedkey() const { + return _internal_has_newencryptedkey(); +} +inline void CreateNewBackupRequest::set_has_newencryptedkey() { + _oneof_case_[0] = kNewEncryptedKey; +} +inline void CreateNewBackupRequest::clear_newencryptedkey() { + if (_internal_has_newencryptedkey()) { + data_.newencryptedkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& CreateNewBackupRequest::newencryptedkey() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.newEncryptedKey) + return _internal_newencryptedkey(); +} +inline void CreateNewBackupRequest::set_newencryptedkey(const std::string& value) { + _internal_set_newencryptedkey(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newEncryptedKey) +} +inline std::string* CreateNewBackupRequest::mutable_newencryptedkey() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.newEncryptedKey) + return _internal_mutable_newencryptedkey(); +} +inline const std::string& CreateNewBackupRequest::_internal_newencryptedkey() const { + if (_internal_has_newencryptedkey()) { + return data_.newencryptedkey_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupRequest::_internal_set_newencryptedkey(const std::string& value) { + if (!_internal_has_newencryptedkey()) { + clear_data(); + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newencryptedkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupRequest::set_newencryptedkey(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newEncryptedKey) + if (!_internal_has_newencryptedkey()) { + clear_data(); + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newencryptedkey_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.newEncryptedKey) +} +inline void CreateNewBackupRequest::set_newencryptedkey(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_newencryptedkey()) { + clear_data(); + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newencryptedkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.newEncryptedKey) +} +inline void CreateNewBackupRequest::set_newencryptedkey(const void* value, + size_t size) { + if (!_internal_has_newencryptedkey()) { + clear_data(); + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newencryptedkey_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.newEncryptedKey) +} +inline std::string* CreateNewBackupRequest::_internal_mutable_newencryptedkey() { + if (!_internal_has_newencryptedkey()) { + clear_data(); + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.newencryptedkey_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* CreateNewBackupRequest::release_newencryptedkey() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.newEncryptedKey) + if (_internal_has_newencryptedkey()) { + clear_has_data(); + return data_.newencryptedkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupRequest::set_allocated_newencryptedkey(std::string* newencryptedkey) { + if (has_data()) { + clear_data(); + } + if (newencryptedkey != nullptr) { + set_has_newencryptedkey(); + data_.newencryptedkey_.UnsafeSetDefault(newencryptedkey); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(newencryptedkey); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newEncryptedKey) +} + +// bytes newCompactionChunk = 3; +inline bool CreateNewBackupRequest::_internal_has_newcompactionchunk() const { + return data_case() == kNewCompactionChunk; +} +inline bool CreateNewBackupRequest::has_newcompactionchunk() const { + return _internal_has_newcompactionchunk(); +} +inline void CreateNewBackupRequest::set_has_newcompactionchunk() { + _oneof_case_[0] = kNewCompactionChunk; +} +inline void CreateNewBackupRequest::clear_newcompactionchunk() { + if (_internal_has_newcompactionchunk()) { + data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& CreateNewBackupRequest::newcompactionchunk() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.newCompactionChunk) + return _internal_newcompactionchunk(); +} +inline void CreateNewBackupRequest::set_newcompactionchunk(const std::string& value) { + _internal_set_newcompactionchunk(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk) +} +inline std::string* CreateNewBackupRequest::mutable_newcompactionchunk() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.newCompactionChunk) + return _internal_mutable_newcompactionchunk(); +} +inline const std::string& CreateNewBackupRequest::_internal_newcompactionchunk() const { + if (_internal_has_newcompactionchunk()) { + return data_.newcompactionchunk_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupRequest::_internal_set_newcompactionchunk(const std::string& value) { + if (!_internal_has_newcompactionchunk()) { + clear_data(); + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupRequest::set_newcompactionchunk(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk) + if (!_internal_has_newcompactionchunk()) { + clear_data(); + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newcompactionchunk_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.newCompactionChunk) +} +inline void CreateNewBackupRequest::set_newcompactionchunk(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_newcompactionchunk()) { + clear_data(); + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.newCompactionChunk) +} +inline void CreateNewBackupRequest::set_newcompactionchunk(const void* value, + size_t size) { + if (!_internal_has_newcompactionchunk()) { + clear_data(); + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.newcompactionchunk_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.newCompactionChunk) +} +inline std::string* CreateNewBackupRequest::_internal_mutable_newcompactionchunk() { + if (!_internal_has_newcompactionchunk()) { + clear_data(); + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.newcompactionchunk_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* CreateNewBackupRequest::release_newcompactionchunk() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.newCompactionChunk) + if (_internal_has_newcompactionchunk()) { + clear_has_data(); + return data_.newcompactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupRequest::set_allocated_newcompactionchunk(std::string* newcompactionchunk) { + if (has_data()) { + clear_data(); + } + if (newcompactionchunk != nullptr) { + set_has_newcompactionchunk(); + data_.newcompactionchunk_.UnsafeSetDefault(newcompactionchunk); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(newcompactionchunk); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newCompactionChunk) +} + +inline bool CreateNewBackupRequest::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void CreateNewBackupRequest::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; } +inline CreateNewBackupRequest::DataCase CreateNewBackupRequest::data_case() const { + return CreateNewBackupRequest::DataCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- -// bytes newKey = 2; -inline bool ResetKeyRequest::_internal_has_newkey() const { - return data_case() == kNewKey; +// CreateNewBackupResponse + +// bytes responseBytes = 1; +inline bool CreateNewBackupResponse::_internal_has_responsebytes() const { + return data_case() == kResponseBytes; } -inline bool ResetKeyRequest::has_newkey() const { - return _internal_has_newkey(); +inline bool CreateNewBackupResponse::has_responsebytes() const { + return _internal_has_responsebytes(); } -inline void ResetKeyRequest::set_has_newkey() { - _oneof_case_[0] = kNewKey; +inline void CreateNewBackupResponse::set_has_responsebytes() { + _oneof_case_[0] = kResponseBytes; } -inline void ResetKeyRequest::clear_newkey() { - if (_internal_has_newkey()) { - data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void CreateNewBackupResponse::clear_responsebytes() { + if (_internal_has_responsebytes()) { + data_.responsebytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); clear_has_data(); } } -inline const std::string& ResetKeyRequest::newkey() const { - // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.newKey) - return _internal_newkey(); +inline const std::string& CreateNewBackupResponse::responsebytes() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.responseBytes) + return _internal_responsebytes(); } -inline void ResetKeyRequest::set_newkey(const std::string& value) { - _internal_set_newkey(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey) +inline void CreateNewBackupResponse::set_responsebytes(const std::string& value) { + _internal_set_responsebytes(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.responseBytes) } -inline std::string* ResetKeyRequest::mutable_newkey() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.newKey) - return _internal_mutable_newkey(); +inline std::string* CreateNewBackupResponse::mutable_responsebytes() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.responseBytes) + return _internal_mutable_responsebytes(); } -inline const std::string& ResetKeyRequest::_internal_newkey() const { - if (_internal_has_newkey()) { - return data_.newkey_.Get(); +inline const std::string& CreateNewBackupResponse::_internal_responsebytes() const { + if (_internal_has_responsebytes()) { + return data_.responsebytes_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void ResetKeyRequest::_internal_set_newkey(const std::string& value) { - if (!_internal_has_newkey()) { +inline void CreateNewBackupResponse::_internal_set_responsebytes(const std::string& value) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + data_.responsebytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void ResetKeyRequest::set_newkey(std::string&& value) { - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey) - if (!_internal_has_newkey()) { +inline void CreateNewBackupResponse::set_responsebytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.responseBytes) + if (!_internal_has_responsebytes()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set( + data_.responsebytes_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.newKey) + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.responseBytes) } -inline void ResetKeyRequest::set_newkey(const char* value) { +inline void CreateNewBackupResponse::set_responsebytes(const char* value) { GOOGLE_DCHECK(value != nullptr); - if (!_internal_has_newkey()) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + data_.responsebytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.newKey) + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.responseBytes) } -inline void ResetKeyRequest::set_newkey(const void* value, +inline void CreateNewBackupResponse::set_responsebytes(const void* value, size_t size) { - if (!_internal_has_newkey()) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set( + data_.responsebytes_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.newKey) + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.responseBytes) } -inline std::string* ResetKeyRequest::_internal_mutable_newkey() { - if (!_internal_has_newkey()) { +inline std::string* CreateNewBackupResponse::_internal_mutable_responsebytes() { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return data_.newkey_.Mutable( + return data_.responsebytes_.Mutable( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* ResetKeyRequest::release_newkey() { - // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.newKey) - if (_internal_has_newkey()) { +inline std::string* CreateNewBackupResponse::release_responsebytes() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.responseBytes) + if (_internal_has_responsebytes()) { clear_has_data(); - return data_.newkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return data_.responsebytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } -inline void ResetKeyRequest::set_allocated_newkey(std::string* newkey) { +inline void CreateNewBackupResponse::set_allocated_responsebytes(std::string* responsebytes) { if (has_data()) { clear_data(); } - if (newkey != nullptr) { - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(newkey); + if (responsebytes != nullptr) { + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(responsebytes); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(newkey); + arena->Own(responsebytes); } } - // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.newKey) + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.responseBytes) } -// bytes compactionChunk = 3; -inline bool ResetKeyRequest::_internal_has_compactionchunk() const { - return data_case() == kCompactionChunk; +// string backupID = 2; +inline bool CreateNewBackupResponse::_internal_has_backupid() const { + return data_case() == kBackupID; } -inline bool ResetKeyRequest::has_compactionchunk() const { - return _internal_has_compactionchunk(); +inline bool CreateNewBackupResponse::has_backupid() const { + return _internal_has_backupid(); } -inline void ResetKeyRequest::set_has_compactionchunk() { - _oneof_case_[0] = kCompactionChunk; +inline void CreateNewBackupResponse::set_has_backupid() { + _oneof_case_[0] = kBackupID; } -inline void ResetKeyRequest::clear_compactionchunk() { - if (_internal_has_compactionchunk()) { - data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void CreateNewBackupResponse::clear_backupid() { + if (_internal_has_backupid()) { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); clear_has_data(); } } -inline const std::string& ResetKeyRequest::compactionchunk() const { - // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.compactionChunk) - return _internal_compactionchunk(); +inline const std::string& CreateNewBackupResponse::backupid() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.backupID) + return _internal_backupid(); } -inline void ResetKeyRequest::set_compactionchunk(const std::string& value) { - _internal_set_compactionchunk(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk) +inline void CreateNewBackupResponse::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID) } -inline std::string* ResetKeyRequest::mutable_compactionchunk() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.compactionChunk) - return _internal_mutable_compactionchunk(); +inline std::string* CreateNewBackupResponse::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.backupID) + return _internal_mutable_backupid(); } -inline const std::string& ResetKeyRequest::_internal_compactionchunk() const { - if (_internal_has_compactionchunk()) { - return data_.compactionchunk_.Get(); +inline const std::string& CreateNewBackupResponse::_internal_backupid() const { + if (_internal_has_backupid()) { + return data_.backupid_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void ResetKeyRequest::_internal_set_compactionchunk(const std::string& value) { - if (!_internal_has_compactionchunk()) { +inline void CreateNewBackupResponse::_internal_set_backupid(const std::string& value) { + if (!_internal_has_backupid()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void ResetKeyRequest::set_compactionchunk(std::string&& value) { - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk) - if (!_internal_has_compactionchunk()) { +inline void CreateNewBackupResponse::set_backupid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID) + if (!_internal_has_backupid()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set( + data_.backupid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.compactionChunk) + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.backupID) } -inline void ResetKeyRequest::set_compactionchunk(const char* value) { +inline void CreateNewBackupResponse::set_backupid(const char* value) { GOOGLE_DCHECK(value != nullptr); - if (!_internal_has_compactionchunk()) { + if (!_internal_has_backupid()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.compactionChunk) + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.backupID) } -inline void ResetKeyRequest::set_compactionchunk(const void* value, +inline void CreateNewBackupResponse::set_backupid(const char* value, size_t size) { - if (!_internal_has_compactionchunk()) { + if (!_internal_has_backupid()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set( + data_.backupid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.compactionChunk) + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.backupID) } -inline std::string* ResetKeyRequest::_internal_mutable_compactionchunk() { - if (!_internal_has_compactionchunk()) { +inline std::string* CreateNewBackupResponse::_internal_mutable_backupid() { + if (!_internal_has_backupid()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return data_.compactionchunk_.Mutable( + return data_.backupid_.Mutable( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* ResetKeyRequest::release_compactionchunk() { - // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.compactionChunk) - if (_internal_has_compactionchunk()) { +inline std::string* CreateNewBackupResponse::release_backupid() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.backupID) + if (_internal_has_backupid()) { clear_has_data(); - return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } -inline void ResetKeyRequest::set_allocated_compactionchunk(std::string* compactionchunk) { +inline void CreateNewBackupResponse::set_allocated_backupid(std::string* backupid) { if (has_data()) { clear_data(); } - if (compactionchunk != nullptr) { - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(compactionchunk); + if (backupid != nullptr) { + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(backupid); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(compactionchunk); + arena->Own(backupid); } } - // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.compactionChunk) + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.backupID) } -inline bool ResetKeyRequest::has_data() const { +inline bool CreateNewBackupResponse::has_data() const { return data_case() != DATA_NOT_SET; } -inline void ResetKeyRequest::clear_has_data() { +inline void CreateNewBackupResponse::clear_has_data() { _oneof_case_[0] = DATA_NOT_SET; } -inline ResetKeyRequest::DataCase ResetKeyRequest::data_case() const { - return ResetKeyRequest::DataCase(_oneof_case_[0]); +inline CreateNewBackupResponse::DataCase CreateNewBackupResponse::data_case() const { + return CreateNewBackupResponse::DataCase(_oneof_case_[0]); } // ------------------------------------------------------------------- // SendLogRequest -// string userId = 1; -inline void SendLogRequest::clear_userid() { - userid_.ClearToEmpty(); +// .backup.SimpleAuthenticationRequestData authenticationData = 1; +inline bool SendLogRequest::_internal_has_authenticationdata() const { + return this != internal_default_instance() && authenticationdata_ != nullptr; } -inline const std::string& SendLogRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.SendLogRequest.userId) - return _internal_userid(); -} -inline void SendLogRequest::set_userid(const std::string& value) { - _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.SendLogRequest.userId) +inline bool SendLogRequest::has_authenticationdata() const { + return _internal_has_authenticationdata(); } -inline std::string* SendLogRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userId) - return _internal_mutable_userid(); +inline void SendLogRequest::clear_authenticationdata() { + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; } -inline const std::string& SendLogRequest::_internal_userid() const { - return userid_.Get(); +inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::_internal_authenticationdata() const { + const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_; + return p != nullptr ? *p : reinterpret_cast( + ::backup::_SimpleAuthenticationRequestData_default_instance_); } -inline void SendLogRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::authenticationdata() const { + // @@protoc_insertion_point(field_get:backup.SendLogRequest.authenticationData) + return _internal_authenticationdata(); } -inline void SendLogRequest::set_userid(std::string&& value) { - - userid_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.userId) +inline void SendLogRequest::unsafe_arena_set_allocated_authenticationdata( + ::backup::SimpleAuthenticationRequestData* authenticationdata) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_); + } + authenticationdata_ = authenticationdata; + if (authenticationdata) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.SendLogRequest.authenticationData) } -inline void SendLogRequest::set_userid(const char* value) { - GOOGLE_DCHECK(value != nullptr); +inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::release_authenticationdata() { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.userId) + ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline void SendLogRequest::set_userid(const char* value, - size_t size) { +inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::unsafe_arena_release_authenticationdata() { + // @@protoc_insertion_point(field_release:backup.SendLogRequest.authenticationData) - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.userId) + ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + return temp; } -inline std::string* SendLogRequest::_internal_mutable_userid() { +inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::_internal_mutable_authenticationdata() { - return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* SendLogRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.SendLogRequest.userId) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void SendLogRequest::set_allocated_userid(std::string* userid) { - if (userid != nullptr) { + if (authenticationdata_ == nullptr) { + auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena()); + authenticationdata_ = p; + } + return authenticationdata_; +} +inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::mutable_authenticationdata() { + // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.authenticationData) + return _internal_mutable_authenticationdata(); +} +inline void SendLogRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete authenticationdata_; + } + if (authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata); + if (message_arena != submessage_arena) { + authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, authenticationdata, submessage_arena); + } } else { } - userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userId) + authenticationdata_ = authenticationdata; + // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.authenticationData) } -// bytes data = 2; -inline void SendLogRequest::clear_data() { - data_.ClearToEmpty(); +// bytes logData = 2; +inline void SendLogRequest::clear_logdata() { + logdata_.ClearToEmpty(); } -inline const std::string& SendLogRequest::data() const { - // @@protoc_insertion_point(field_get:backup.SendLogRequest.data) - return _internal_data(); +inline const std::string& SendLogRequest::logdata() const { + // @@protoc_insertion_point(field_get:backup.SendLogRequest.logData) + return _internal_logdata(); } -inline void SendLogRequest::set_data(const std::string& value) { - _internal_set_data(value); - // @@protoc_insertion_point(field_set:backup.SendLogRequest.data) +inline void SendLogRequest::set_logdata(const std::string& value) { + _internal_set_logdata(value); + // @@protoc_insertion_point(field_set:backup.SendLogRequest.logData) } -inline std::string* SendLogRequest::mutable_data() { - // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.data) - return _internal_mutable_data(); +inline std::string* SendLogRequest::mutable_logdata() { + // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.logData) + return _internal_mutable_logdata(); } -inline const std::string& SendLogRequest::_internal_data() const { - return data_.Get(); +inline const std::string& SendLogRequest::_internal_logdata() const { + return logdata_.Get(); } -inline void SendLogRequest::_internal_set_data(const std::string& value) { +inline void SendLogRequest::_internal_set_logdata(const std::string& value) { - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void SendLogRequest::set_data(std::string&& value) { +inline void SendLogRequest::set_logdata(std::string&& value) { - data_.Set( + logdata_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.data) + // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.logData) } -inline void SendLogRequest::set_data(const char* value) { +inline void SendLogRequest::set_logdata(const char* value) { GOOGLE_DCHECK(value != nullptr); - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.data) + logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.logData) } -inline void SendLogRequest::set_data(const void* value, +inline void SendLogRequest::set_logdata(const void* value, size_t size) { - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.data) + // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.logData) } -inline std::string* SendLogRequest::_internal_mutable_data() { +inline std::string* SendLogRequest::_internal_mutable_logdata() { - return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return logdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* SendLogRequest::release_data() { - // @@protoc_insertion_point(field_release:backup.SendLogRequest.data) - return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* SendLogRequest::release_logdata() { + // @@protoc_insertion_point(field_release:backup.SendLogRequest.logData) + return logdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void SendLogRequest::set_allocated_data(std::string* data) { - if (data != nullptr) { +inline void SendLogRequest::set_allocated_logdata(std::string* logdata) { + if (logdata != nullptr) { } else { } - data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data, + logdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logdata, GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.data) + // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.logData) } // ------------------------------------------------------------------- // PullBackupKeyRequest -// string userId = 1; -inline void PullBackupKeyRequest::clear_userid() { - userid_.ClearToEmpty(); -} -inline const std::string& PullBackupKeyRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.userId) - return _internal_userid(); -} -inline void PullBackupKeyRequest::set_userid(const std::string& value) { - _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.userId) -} -inline std::string* PullBackupKeyRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.userId) - return _internal_mutable_userid(); -} -inline const std::string& PullBackupKeyRequest::_internal_userid() const { - return userid_.Get(); -} -inline void PullBackupKeyRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline void PullBackupKeyRequest::set_userid(std::string&& value) { - - userid_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.userId) +// .backup.FullAuthenticationRequestData authenticationData = 1; +inline bool PullBackupKeyRequest::_internal_has_authenticationdata() const { + return this != internal_default_instance() && authenticationdata_ != nullptr; } -inline void PullBackupKeyRequest::set_userid(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.userId) +inline bool PullBackupKeyRequest::has_authenticationdata() const { + return _internal_has_authenticationdata(); } -inline void PullBackupKeyRequest::set_userid(const char* value, - size_t size) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.userId) +inline void PullBackupKeyRequest::clear_authenticationdata() { + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; } -inline std::string* PullBackupKeyRequest::_internal_mutable_userid() { - - return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline const ::backup::FullAuthenticationRequestData& PullBackupKeyRequest::_internal_authenticationdata() const { + const ::backup::FullAuthenticationRequestData* p = authenticationdata_; + return p != nullptr ? *p : reinterpret_cast( + ::backup::_FullAuthenticationRequestData_default_instance_); } -inline std::string* PullBackupKeyRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userId) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline const ::backup::FullAuthenticationRequestData& PullBackupKeyRequest::authenticationdata() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.authenticationData) + return _internal_authenticationdata(); } -inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) { - if (userid != nullptr) { +inline void PullBackupKeyRequest::unsafe_arena_set_allocated_authenticationdata( + ::backup::FullAuthenticationRequestData* authenticationdata) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_); + } + authenticationdata_ = authenticationdata; + if (authenticationdata) { } else { } - userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.userId) -} - -// bytes pakeKey = 2; -inline void PullBackupKeyRequest::clear_pakekey() { - pakekey_.ClearToEmpty(); -} -inline const std::string& PullBackupKeyRequest::pakekey() const { - // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.pakeKey) - return _internal_pakekey(); -} -inline void PullBackupKeyRequest::set_pakekey(const std::string& value) { - _internal_set_pakekey(value); - // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.pakeKey) -} -inline std::string* PullBackupKeyRequest::mutable_pakekey() { - // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.pakeKey) - return _internal_mutable_pakekey(); -} -inline const std::string& PullBackupKeyRequest::_internal_pakekey() const { - return pakekey_.Get(); -} -inline void PullBackupKeyRequest::_internal_set_pakekey(const std::string& value) { - - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline void PullBackupKeyRequest::set_pakekey(std::string&& value) { - - pakekey_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.pakeKey) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PullBackupKeyRequest.authenticationData) } -inline void PullBackupKeyRequest::set_pakekey(const char* value) { - GOOGLE_DCHECK(value != nullptr); +inline ::backup::FullAuthenticationRequestData* PullBackupKeyRequest::release_authenticationdata() { - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.pakeKey) + ::backup::FullAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline void PullBackupKeyRequest::set_pakekey(const void* value, - size_t size) { +inline ::backup::FullAuthenticationRequestData* PullBackupKeyRequest::unsafe_arena_release_authenticationdata() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.authenticationData) - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.pakeKey) + ::backup::FullAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + return temp; } -inline std::string* PullBackupKeyRequest::_internal_mutable_pakekey() { +inline ::backup::FullAuthenticationRequestData* PullBackupKeyRequest::_internal_mutable_authenticationdata() { - return pakekey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* PullBackupKeyRequest::release_pakekey() { - // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.pakeKey) - return pakekey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void PullBackupKeyRequest::set_allocated_pakekey(std::string* pakekey) { - if (pakekey != nullptr) { + if (authenticationdata_ == nullptr) { + auto* p = CreateMaybeMessage<::backup::FullAuthenticationRequestData>(GetArena()); + authenticationdata_ = p; + } + return authenticationdata_; +} +inline ::backup::FullAuthenticationRequestData* PullBackupKeyRequest::mutable_authenticationdata() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.authenticationData) + return _internal_mutable_authenticationdata(); +} +inline void PullBackupKeyRequest::set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete authenticationdata_; + } + if (authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata); + if (message_arena != submessage_arena) { + authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, authenticationdata, submessage_arena); + } } else { } - pakekey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakekey, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.pakeKey) + authenticationdata_ = authenticationdata; + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.authenticationData) } // ------------------------------------------------------------------- // PullBackupKeyResponse -// bytes encryptedBackupKey = 1; -inline void PullBackupKeyResponse::clear_encryptedbackupkey() { - encryptedbackupkey_.ClearToEmpty(); +// bytes responseBytes = 1; +inline bool PullBackupKeyResponse::_internal_has_responsebytes() const { + return data_case() == kResponseBytes; } -inline const std::string& PullBackupKeyResponse::encryptedbackupkey() const { - // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupKey) - return _internal_encryptedbackupkey(); +inline bool PullBackupKeyResponse::has_responsebytes() const { + return _internal_has_responsebytes(); } -inline void PullBackupKeyResponse::set_encryptedbackupkey(const std::string& value) { - _internal_set_encryptedbackupkey(value); - // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupKey) +inline void PullBackupKeyResponse::set_has_responsebytes() { + _oneof_case_[0] = kResponseBytes; } -inline std::string* PullBackupKeyResponse::mutable_encryptedbackupkey() { - // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupKey) - return _internal_mutable_encryptedbackupkey(); +inline void PullBackupKeyResponse::clear_responsebytes() { + if (_internal_has_responsebytes()) { + data_.responsebytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } } -inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupkey() const { - return encryptedbackupkey_.Get(); +inline const std::string& PullBackupKeyResponse::responsebytes() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.responseBytes) + return _internal_responsebytes(); } -inline void PullBackupKeyResponse::_internal_set_encryptedbackupkey(const std::string& value) { - - encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline void PullBackupKeyResponse::set_responsebytes(const std::string& value) { + _internal_set_responsebytes(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.responseBytes) } -inline void PullBackupKeyResponse::set_encryptedbackupkey(std::string&& value) { - - encryptedbackupkey_.Set( +inline std::string* PullBackupKeyResponse::mutable_responsebytes() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.responseBytes) + return _internal_mutable_responsebytes(); +} +inline const std::string& PullBackupKeyResponse::_internal_responsebytes() const { + if (_internal_has_responsebytes()) { + return data_.responsebytes_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupKeyResponse::_internal_set_responsebytes(const std::string& value) { + if (!_internal_has_responsebytes()) { + clear_data(); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.responsebytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupKeyResponse::set_responsebytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.responseBytes) + if (!_internal_has_responsebytes()) { + clear_data(); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.responsebytes_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupKey) + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.responseBytes) } -inline void PullBackupKeyResponse::set_encryptedbackupkey(const char* value) { +inline void PullBackupKeyResponse::set_responsebytes(const char* value) { GOOGLE_DCHECK(value != nullptr); - - encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.encryptedBackupKey) -} -inline void PullBackupKeyResponse::set_encryptedbackupkey(const void* value, - size_t size) { - - encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupKey) + if (!_internal_has_responsebytes()) { + clear_data(); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.responsebytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.responseBytes) } -inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupkey() { - - return encryptedbackupkey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void PullBackupKeyResponse::set_responsebytes(const void* value, + size_t size) { + if (!_internal_has_responsebytes()) { + clear_data(); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.responsebytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.responseBytes) } -inline std::string* PullBackupKeyResponse::release_encryptedbackupkey() { - // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupKey) - return encryptedbackupkey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* PullBackupKeyResponse::_internal_mutable_responsebytes() { + if (!_internal_has_responsebytes()) { + clear_data(); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.responsebytes_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline void PullBackupKeyResponse::set_allocated_encryptedbackupkey(std::string* encryptedbackupkey) { - if (encryptedbackupkey != nullptr) { - +inline std::string* PullBackupKeyResponse::release_responsebytes() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.responseBytes) + if (_internal_has_responsebytes()) { + clear_has_data(); + return data_.responsebytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { - + return nullptr; } - encryptedbackupkey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryptedbackupkey, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupKey) +} +inline void PullBackupKeyResponse::set_allocated_responsebytes(std::string* responsebytes) { + if (has_data()) { + clear_data(); + } + if (responsebytes != nullptr) { + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(responsebytes); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(responsebytes); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.responseBytes) } -// ------------------------------------------------------------------- - -// PullCompactionRequest - -// string userId = 1; -inline void PullCompactionRequest::clear_userid() { - userid_.ClearToEmpty(); +// bytes encryptedBackupIDAndKey = 2; +inline bool PullBackupKeyResponse::_internal_has_encryptedbackupidandkey() const { + return data_case() == kEncryptedBackupIDAndKey; } -inline const std::string& PullCompactionRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userId) - return _internal_userid(); +inline bool PullBackupKeyResponse::has_encryptedbackupidandkey() const { + return _internal_has_encryptedbackupidandkey(); } -inline void PullCompactionRequest::set_userid(const std::string& value) { - _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userId) +inline void PullBackupKeyResponse::set_has_encryptedbackupidandkey() { + _oneof_case_[0] = kEncryptedBackupIDAndKey; } -inline std::string* PullCompactionRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userId) - return _internal_mutable_userid(); +inline void PullBackupKeyResponse::clear_encryptedbackupidandkey() { + if (_internal_has_encryptedbackupidandkey()) { + data_.encryptedbackupidandkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } } -inline const std::string& PullCompactionRequest::_internal_userid() const { - return userid_.Get(); +inline const std::string& PullBackupKeyResponse::encryptedbackupidandkey() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + return _internal_encryptedbackupidandkey(); } -inline void PullCompactionRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline void PullBackupKeyResponse::set_encryptedbackupidandkey(const std::string& value) { + _internal_set_encryptedbackupidandkey(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline void PullCompactionRequest::set_userid(std::string&& value) { - - userid_.Set( +inline std::string* PullBackupKeyResponse::mutable_encryptedbackupidandkey() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + return _internal_mutable_encryptedbackupidandkey(); +} +inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupidandkey() const { + if (_internal_has_encryptedbackupidandkey()) { + return data_.encryptedbackupidandkey_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupKeyResponse::_internal_set_encryptedbackupidandkey(const std::string& value) { + if (!_internal_has_encryptedbackupidandkey()) { + clear_data(); + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.encryptedbackupidandkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupKeyResponse::set_encryptedbackupidandkey(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + if (!_internal_has_encryptedbackupidandkey()) { + clear_data(); + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.encryptedbackupidandkey_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.userId) + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline void PullCompactionRequest::set_userid(const char* value) { +inline void PullBackupKeyResponse::set_encryptedbackupidandkey(const char* value) { GOOGLE_DCHECK(value != nullptr); - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.userId) -} -inline void PullCompactionRequest::set_userid(const char* value, - size_t size) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.userId) + if (!_internal_has_encryptedbackupidandkey()) { + clear_data(); + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.encryptedbackupidandkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline std::string* PullCompactionRequest::_internal_mutable_userid() { - - return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void PullBackupKeyResponse::set_encryptedbackupidandkey(const void* value, + size_t size) { + if (!_internal_has_encryptedbackupidandkey()) { + clear_data(); + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.encryptedbackupidandkey_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline std::string* PullCompactionRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userId) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupidandkey() { + if (!_internal_has_encryptedbackupidandkey()) { + clear_data(); + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.encryptedbackupidandkey_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline void PullCompactionRequest::set_allocated_userid(std::string* userid) { - if (userid != nullptr) { - +inline std::string* PullBackupKeyResponse::release_encryptedbackupidandkey() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + if (_internal_has_encryptedbackupidandkey()) { + clear_has_data(); + return data_.encryptedbackupidandkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { - + return nullptr; } - userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userId) +} +inline void PullBackupKeyResponse::set_allocated_encryptedbackupidandkey(std::string* encryptedbackupidandkey) { + if (has_data()) { + clear_data(); + } + if (encryptedbackupidandkey != nullptr) { + set_has_encryptedbackupidandkey(); + data_.encryptedbackupidandkey_.UnsafeSetDefault(encryptedbackupidandkey); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(encryptedbackupidandkey); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -// bytes message = 2; -inline void PullCompactionRequest::clear_message() { - message_.ClearToEmpty(); +inline bool PullBackupKeyResponse::has_data() const { + return data_case() != DATA_NOT_SET; } -inline const std::string& PullCompactionRequest::message() const { - // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.message) - return _internal_message(); +inline void PullBackupKeyResponse::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; } -inline void PullCompactionRequest::set_message(const std::string& value) { - _internal_set_message(value); - // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.message) +inline PullBackupKeyResponse::DataCase PullBackupKeyResponse::data_case() const { + return PullBackupKeyResponse::DataCase(_oneof_case_[0]); } -inline std::string* PullCompactionRequest::mutable_message() { - // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.message) - return _internal_mutable_message(); +// ------------------------------------------------------------------- + +// PullCompactionRequest + +// .backup.SimpleAuthenticationRequestData authenticationData = 1; +inline bool PullCompactionRequest::_internal_has_authenticationdata() const { + return this != internal_default_instance() && authenticationdata_ != nullptr; } -inline const std::string& PullCompactionRequest::_internal_message() const { - return message_.Get(); +inline bool PullCompactionRequest::has_authenticationdata() const { + return _internal_has_authenticationdata(); } -inline void PullCompactionRequest::_internal_set_message(const std::string& value) { - - message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline void PullCompactionRequest::clear_authenticationdata() { + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; } -inline void PullCompactionRequest::set_message(std::string&& value) { - - message_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.message) +inline const ::backup::SimpleAuthenticationRequestData& PullCompactionRequest::_internal_authenticationdata() const { + const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_; + return p != nullptr ? *p : reinterpret_cast( + ::backup::_SimpleAuthenticationRequestData_default_instance_); } -inline void PullCompactionRequest::set_message(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.message) +inline const ::backup::SimpleAuthenticationRequestData& PullCompactionRequest::authenticationdata() const { + // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.authenticationData) + return _internal_authenticationdata(); } -inline void PullCompactionRequest::set_message(const void* value, - size_t size) { - - message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.message) +inline void PullCompactionRequest::unsafe_arena_set_allocated_authenticationdata( + ::backup::SimpleAuthenticationRequestData* authenticationdata) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_); + } + authenticationdata_ = authenticationdata; + if (authenticationdata) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PullCompactionRequest.authenticationData) } -inline std::string* PullCompactionRequest::_internal_mutable_message() { +inline ::backup::SimpleAuthenticationRequestData* PullCompactionRequest::release_authenticationdata() { - return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline std::string* PullCompactionRequest::release_message() { - // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.message) - return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline ::backup::SimpleAuthenticationRequestData* PullCompactionRequest::unsafe_arena_release_authenticationdata() { + // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.authenticationData) + + ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_; + authenticationdata_ = nullptr; + return temp; } -inline void PullCompactionRequest::set_allocated_message(std::string* message) { - if (message != nullptr) { +inline ::backup::SimpleAuthenticationRequestData* PullCompactionRequest::_internal_mutable_authenticationdata() { + + if (authenticationdata_ == nullptr) { + auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena()); + authenticationdata_ = p; + } + return authenticationdata_; +} +inline ::backup::SimpleAuthenticationRequestData* PullCompactionRequest::mutable_authenticationdata() { + // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.authenticationData) + return _internal_mutable_authenticationdata(); +} +inline void PullCompactionRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete authenticationdata_; + } + if (authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata); + if (message_arena != submessage_arena) { + authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, authenticationdata, submessage_arena); + } } else { } - message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.message) + authenticationdata_ = authenticationdata; + // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.authenticationData) } // ------------------------------------------------------------------- @@ -2101,6 +3254,12 @@ // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc @@ -17,23 +17,60 @@ PROTOBUF_PRAGMA_INIT_SEG namespace backup { -constexpr ResetKeyRequest::ResetKeyRequest( +constexpr FullAuthenticationRequestData::FullAuthenticationRequestData( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , _oneof_case_{}{} -struct ResetKeyRequestDefaultTypeInternal { - constexpr ResetKeyRequestDefaultTypeInternal() + : requestbytes_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct FullAuthenticationRequestDataDefaultTypeInternal { + constexpr FullAuthenticationRequestDataDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ResetKeyRequestDefaultTypeInternal() {} + ~FullAuthenticationRequestDataDefaultTypeInternal() {} union { - ResetKeyRequest _instance; + FullAuthenticationRequestData _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_; +constexpr SimpleAuthenticationRequestData::SimpleAuthenticationRequestData( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : backupid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct SimpleAuthenticationRequestDataDefaultTypeInternal { + constexpr SimpleAuthenticationRequestDataDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleAuthenticationRequestDataDefaultTypeInternal() {} + union { + SimpleAuthenticationRequestData _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_; +constexpr CreateNewBackupRequest::CreateNewBackupRequest( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct CreateNewBackupRequestDefaultTypeInternal { + constexpr CreateNewBackupRequestDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CreateNewBackupRequestDefaultTypeInternal() {} + union { + CreateNewBackupRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_; +constexpr CreateNewBackupResponse::CreateNewBackupResponse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct CreateNewBackupResponseDefaultTypeInternal { + constexpr CreateNewBackupResponseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CreateNewBackupResponseDefaultTypeInternal() {} + union { + CreateNewBackupResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_; constexpr SendLogRequest::SendLogRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} + : logdata_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , authenticationdata_(nullptr){} struct SendLogRequestDefaultTypeInternal { constexpr SendLogRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -45,8 +82,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_; constexpr PullBackupKeyRequest::PullBackupKeyRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , pakekey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} + : authenticationdata_(nullptr){} struct PullBackupKeyRequestDefaultTypeInternal { constexpr PullBackupKeyRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -58,7 +94,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_; constexpr PullBackupKeyResponse::PullBackupKeyResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : encryptedbackupkey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} + : _oneof_case_{}{} struct PullBackupKeyResponseDefaultTypeInternal { constexpr PullBackupKeyResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -70,8 +106,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_; constexpr PullCompactionRequest::PullCompactionRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} + : authenticationdata_(nullptr){} struct PullCompactionRequestDefaultTypeInternal { constexpr PullCompactionRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -94,47 +129,69 @@ }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_; } // namespace backup -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[6]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[9]; static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_backup_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_backup_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_backup_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, requestbytes_), + PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, userid_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, backupid_), + PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, userid_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, userid_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, data_), + PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, userid_), - PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_), + PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, authenticationdata_), + PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, logdata_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, userid_), - PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, pakekey_), + PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, authenticationdata_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, _internal_metadata_), ~0u, // no _extensions_ - ~0u, // no _oneof_case_ + PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, encryptedbackupkey_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, userid_), - PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, message_), + PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, authenticationdata_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _internal_metadata_), ~0u, // no _extensions_ @@ -145,139 +202,940 @@ PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, data_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::backup::ResetKeyRequest)}, - { 9, -1, sizeof(::backup::SendLogRequest)}, - { 16, -1, sizeof(::backup::PullBackupKeyRequest)}, - { 23, -1, sizeof(::backup::PullBackupKeyResponse)}, - { 29, -1, sizeof(::backup::PullCompactionRequest)}, - { 36, -1, sizeof(::backup::PullCompactionResponse)}, + { 0, -1, sizeof(::backup::FullAuthenticationRequestData)}, + { 7, -1, sizeof(::backup::SimpleAuthenticationRequestData)}, + { 14, -1, sizeof(::backup::CreateNewBackupRequest)}, + { 23, -1, sizeof(::backup::CreateNewBackupResponse)}, + { 31, -1, sizeof(::backup::SendLogRequest)}, + { 38, -1, sizeof(::backup::PullBackupKeyRequest)}, + { 44, -1, sizeof(::backup::PullBackupKeyResponse)}, + { 52, -1, sizeof(::backup::PullCompactionRequest)}, + { 58, -1, sizeof(::backup::PullCompactionResponse)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::backup::_FullAuthenticationRequestData_default_instance_), + reinterpret_cast(&::backup::_SimpleAuthenticationRequestData_default_instance_), + reinterpret_cast(&::backup::_CreateNewBackupRequest_default_instance_), + reinterpret_cast(&::backup::_CreateNewBackupResponse_default_instance_), + reinterpret_cast(&::backup::_SendLogRequest_default_instance_), + reinterpret_cast(&::backup::_PullBackupKeyRequest_default_instance_), + reinterpret_cast(&::backup::_PullBackupKeyResponse_default_instance_), + reinterpret_cast(&::backup::_PullCompactionRequest_default_instance_), + reinterpret_cast(&::backup::_PullCompactionResponse_default_instance_), +}; + +const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\014backup.proto\022\006backup\032\033google/protobuf/" + "empty.proto\"E\n\035FullAuthenticationRequest" + "Data\022\024\n\014requestBytes\030\001 \001(\014\022\016\n\006userID\030\002 \001" + "(\t\"C\n\037SimpleAuthenticationRequestData\022\020\n" + "\010backupID\030\001 \001(\t\022\016\n\006userID\030\002 \001(\t\"\236\001\n\026Crea" + "teNewBackupRequest\022C\n\022authenticationData" + "\030\001 \001(\0132%.backup.FullAuthenticationReques" + "tDataH\000\022\031\n\017newEncryptedKey\030\002 \001(\014H\000\022\034\n\022ne" + "wCompactionChunk\030\003 \001(\014H\000B\006\n\004data\"N\n\027Crea" + "teNewBackupResponse\022\027\n\rresponseBytes\030\001 \001" + "(\014H\000\022\022\n\010backupID\030\002 \001(\tH\000B\006\n\004data\"f\n\016Send" + "LogRequest\022C\n\022authenticationData\030\001 \001(\0132\'" + ".backup.SimpleAuthenticationRequestData\022" + "\017\n\007logData\030\002 \001(\014\"Y\n\024PullBackupKeyRequest" + "\022A\n\022authenticationData\030\001 \001(\0132%.backup.Fu" + "llAuthenticationRequestData\"[\n\025PullBacku" + "pKeyResponse\022\027\n\rresponseBytes\030\001 \001(\014H\000\022!\n" + "\027encryptedBackupIDAndKey\030\002 \001(\014H\000B\006\n\004data" + "\"\\\n\025PullCompactionRequest\022C\n\022authenticat" + "ionData\030\001 \001(\0132\'.backup.SimpleAuthenticat" + "ionRequestData\"O\n\026PullCompactionResponse" + "\022\031\n\017compactionChunk\030\001 \001(\014H\000\022\022\n\010logChunk\030" + "\002 \001(\014H\000B\006\n\004data2\323\002\n\rBackupService\022X\n\017Cre" + "ateNewBackup\022\036.backup.CreateNewBackupReq" + "uest\032\037.backup.CreateNewBackupResponse\"\000(" + "\0010\001\022=\n\007SendLog\022\026.backup.SendLogRequest\032\026" + ".google.protobuf.Empty\"\000(\001\022R\n\rPullBackup" + "Key\022\034.backup.PullBackupKeyRequest\032\035.back" + "up.PullBackupKeyResponse\"\000(\0010\001\022U\n\016PullCo" + "mpaction\022\035.backup.PullCompactionRequest\032" + "\036.backup.PullCompactionResponse\"\000(\0010\001b\006p" + "roto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = { + &::descriptor_table_google_2fprotobuf_2fempty_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = { + false, false, 1245, descriptor_table_protodef_backup_2eproto, "backup.proto", + &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 9, + schemas, file_default_instances, TableStruct_backup_2eproto::offsets, + file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK ::PROTOBUF_NAMESPACE_ID::Metadata +descriptor_table_backup_2eproto_metadata_getter(int index) { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_backup_2eproto); + return descriptor_table_backup_2eproto.file_level_metadata[index]; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto); +namespace backup { + +// =================================================================== + +class FullAuthenticationRequestData::_Internal { + public: +}; + +FullAuthenticationRequestData::FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationRequestData) +} +FullAuthenticationRequestData::FullAuthenticationRequestData(const FullAuthenticationRequestData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_requestbytes().empty()) { + requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_requestbytes(), + GetArena()); + } + userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_userid().empty()) { + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationRequestData) +} + +void FullAuthenticationRequestData::SharedCtor() { +requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +FullAuthenticationRequestData::~FullAuthenticationRequestData() { + // @@protoc_insertion_point(destructor:backup.FullAuthenticationRequestData) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FullAuthenticationRequestData::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + requestbytes_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FullAuthenticationRequestData::ArenaDtor(void* object) { + FullAuthenticationRequestData* _this = reinterpret_cast< FullAuthenticationRequestData* >(object); + (void)_this; +} +void FullAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FullAuthenticationRequestData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FullAuthenticationRequestData::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + requestbytes_.ClearToEmpty(); + userid_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FullAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // bytes requestBytes = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_requestbytes(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string userID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_userid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.FullAuthenticationRequestData.userID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationRequestData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes requestBytes = 1; + if (this->requestbytes().size() > 0) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_requestbytes(), target); + } + + // string userID = 2; + if (this->userid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_userid().data(), static_cast(this->_internal_userid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.FullAuthenticationRequestData.userID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_userid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationRequestData) + return target; +} + +size_t FullAuthenticationRequestData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationRequestData) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // bytes requestBytes = 1; + if (this->requestbytes().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_requestbytes()); + } + + // string userID = 2; + if (this->userid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FullAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationRequestData) + GOOGLE_DCHECK_NE(&from, this); + const FullAuthenticationRequestData* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationRequestData) + MergeFrom(*source); + } +} + +void FullAuthenticationRequestData::MergeFrom(const FullAuthenticationRequestData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationRequestData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.requestbytes().size() > 0) { + _internal_set_requestbytes(from._internal_requestbytes()); + } + if (from.userid().size() > 0) { + _internal_set_userid(from._internal_userid()); + } +} + +void FullAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationRequestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FullAuthenticationRequestData::CopyFrom(const FullAuthenticationRequestData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationRequestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FullAuthenticationRequestData::IsInitialized() const { + return true; +} + +void FullAuthenticationRequestData::InternalSwap(FullAuthenticationRequestData* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + requestbytes_.Swap(&other->requestbytes_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationRequestData::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class SimpleAuthenticationRequestData::_Internal { + public: }; -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::backup::_ResetKeyRequest_default_instance_), - reinterpret_cast(&::backup::_SendLogRequest_default_instance_), - reinterpret_cast(&::backup::_PullBackupKeyRequest_default_instance_), - reinterpret_cast(&::backup::_PullBackupKeyResponse_default_instance_), - reinterpret_cast(&::backup::_PullCompactionRequest_default_instance_), - reinterpret_cast(&::backup::_PullCompactionResponse_default_instance_), -}; +SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.SimpleAuthenticationRequestData) +} +SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_backupid().empty()) { + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_backupid(), + GetArena()); + } + userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_userid().empty()) { + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:backup.SimpleAuthenticationRequestData) +} + +void SimpleAuthenticationRequestData::SharedCtor() { +backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +SimpleAuthenticationRequestData::~SimpleAuthenticationRequestData() { + // @@protoc_insertion_point(destructor:backup.SimpleAuthenticationRequestData) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleAuthenticationRequestData::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + backupid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SimpleAuthenticationRequestData::ArenaDtor(void* object) { + SimpleAuthenticationRequestData* _this = reinterpret_cast< SimpleAuthenticationRequestData* >(object); + (void)_this; +} +void SimpleAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleAuthenticationRequestData::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleAuthenticationRequestData::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.SimpleAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + backupid_.ClearToEmpty(); + userid_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string backupID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_backupid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.backupID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string userID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_userid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.userID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleAuthenticationRequestData::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.SimpleAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string backupID = 1; + if (this->backupid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_backupid().data(), static_cast(this->_internal_backupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.SimpleAuthenticationRequestData.backupID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_backupid(), target); + } + + // string userID = 2; + if (this->userid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_userid().data(), static_cast(this->_internal_userid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.SimpleAuthenticationRequestData.userID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_userid(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:backup.SimpleAuthenticationRequestData) + return target; +} + +size_t SimpleAuthenticationRequestData::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.SimpleAuthenticationRequestData) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string backupID = 1; + if (this->backupid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + } + + // string userID = 2; + if (this->userid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.SimpleAuthenticationRequestData) + GOOGLE_DCHECK_NE(&from, this); + const SimpleAuthenticationRequestData* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.SimpleAuthenticationRequestData) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.SimpleAuthenticationRequestData) + MergeFrom(*source); + } +} + +void SimpleAuthenticationRequestData::MergeFrom(const SimpleAuthenticationRequestData& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.SimpleAuthenticationRequestData) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.backupid().size() > 0) { + _internal_set_backupid(from._internal_backupid()); + } + if (from.userid().size() > 0) { + _internal_set_userid(from._internal_userid()); + } +} + +void SimpleAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.SimpleAuthenticationRequestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleAuthenticationRequestData::CopyFrom(const SimpleAuthenticationRequestData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.SimpleAuthenticationRequestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleAuthenticationRequestData::IsInitialized() const { + return true; +} + +void SimpleAuthenticationRequestData::InternalSwap(SimpleAuthenticationRequestData* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + backupid_.Swap(&other->backupid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleAuthenticationRequestData::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class CreateNewBackupRequest::_Internal { + public: + static const ::backup::FullAuthenticationRequestData& authenticationdata(const CreateNewBackupRequest* msg); +}; + +const ::backup::FullAuthenticationRequestData& +CreateNewBackupRequest::_Internal::authenticationdata(const CreateNewBackupRequest* msg) { + return *msg->data_.authenticationdata_; +} +void CreateNewBackupRequest::set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (authenticationdata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata); + if (message_arena != submessage_arena) { + authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, authenticationdata, submessage_arena); + } + set_has_authenticationdata(); + data_.authenticationdata_ = authenticationdata; + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationData) +} +CreateNewBackupRequest::CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupRequest) +} +CreateNewBackupRequest::CreateNewBackupRequest(const CreateNewBackupRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_data(); + switch (from.data_case()) { + case kAuthenticationData: { + _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata()); + break; + } + case kNewEncryptedKey: { + _internal_set_newencryptedkey(from._internal_newencryptedkey()); + break; + } + case kNewCompactionChunk: { + _internal_set_newcompactionchunk(from._internal_newcompactionchunk()); + break; + } + case DATA_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupRequest) +} + +void CreateNewBackupRequest::SharedCtor() { +clear_has_data(); +} + +CreateNewBackupRequest::~CreateNewBackupRequest() { + // @@protoc_insertion_point(destructor:backup.CreateNewBackupRequest) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CreateNewBackupRequest::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_data()) { + clear_data(); + } +} + +void CreateNewBackupRequest::ArenaDtor(void* object) { + CreateNewBackupRequest* _this = reinterpret_cast< CreateNewBackupRequest* >(object); + (void)_this; +} +void CreateNewBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CreateNewBackupRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CreateNewBackupRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupRequest) + switch (data_case()) { + case kAuthenticationData: { + if (GetArena() == nullptr) { + delete data_.authenticationdata_; + } + break; + } + case kNewEncryptedKey: { + data_.newencryptedkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kNewCompactionChunk: { + data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + +void CreateNewBackupRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_data(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CreateNewBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .backup.FullAuthenticationRequestData authenticationData = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes newEncryptedKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_newencryptedkey(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes newCompactionChunk = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_newcompactionchunk(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .backup.FullAuthenticationRequestData authenticationData = 1; + if (_internal_has_authenticationdata()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::authenticationdata(this), target, stream); + } + + // bytes newEncryptedKey = 2; + if (_internal_has_newencryptedkey()) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_newencryptedkey(), target); + } + + // bytes newCompactionChunk = 3; + if (_internal_has_newcompactionchunk()) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_newcompactionchunk(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupRequest) + return target; +} + +size_t CreateNewBackupRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupRequest) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (data_case()) { + // .backup.FullAuthenticationRequestData authenticationData = 1; + case kAuthenticationData: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.authenticationdata_); + break; + } + // bytes newEncryptedKey = 2; + case kNewEncryptedKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_newencryptedkey()); + break; + } + // bytes newCompactionChunk = 3; + case kNewCompactionChunk: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_newcompactionchunk()); + break; + } + case DATA_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CreateNewBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupRequest) + GOOGLE_DCHECK_NE(&from, this); + const CreateNewBackupRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupRequest) + MergeFrom(*source); + } +} + +void CreateNewBackupRequest::MergeFrom(const CreateNewBackupRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.data_case()) { + case kAuthenticationData: { + _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata()); + break; + } + case kNewEncryptedKey: { + _internal_set_newencryptedkey(from._internal_newencryptedkey()); + break; + } + case kNewCompactionChunk: { + _internal_set_newcompactionchunk(from._internal_newcompactionchunk()); + break; + } + case DATA_NOT_SET: { + break; + } + } +} + +void CreateNewBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CreateNewBackupRequest::CopyFrom(const CreateNewBackupRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} -const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\014backup.proto\022\006backup\032\033google/protobuf/" - "empty.proto\"V\n\017ResetKeyRequest\022\016\n\006userId" - "\030\001 \001(\t\022\020\n\006newKey\030\002 \001(\014H\000\022\031\n\017compactionCh" - "unk\030\003 \001(\014H\000B\006\n\004data\".\n\016SendLogRequest\022\016\n" - "\006userId\030\001 \001(\t\022\014\n\004data\030\002 \001(\014\"7\n\024PullBacku" - "pKeyRequest\022\016\n\006userId\030\001 \001(\t\022\017\n\007pakeKey\030\002" - " \001(\014\"3\n\025PullBackupKeyResponse\022\032\n\022encrypt" - "edBackupKey\030\001 \001(\014\"8\n\025PullCompactionReque" - "st\022\016\n\006userId\030\001 \001(\t\022\017\n\007message\030\002 \001(\014\"O\n\026P" - "ullCompactionResponse\022\031\n\017compactionChunk" - "\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004data2\262\002\n" - "\rBackupService\022\?\n\010ResetKey\022\027.backup.Rese" - "tKeyRequest\032\026.google.protobuf.Empty\"\000(\001\022" - ";\n\007SendLog\022\026.backup.SendLogRequest\032\026.goo" - "gle.protobuf.Empty\"\000\022N\n\rPullBackupKey\022\034." - "backup.PullBackupKeyRequest\032\035.backup.Pul" - "lBackupKeyResponse\"\000\022S\n\016PullCompaction\022\035" - ".backup.PullCompactionRequest\032\036.backup.P" - "ullCompactionResponse\"\0000\001b\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = { - &::descriptor_table_google_2fprotobuf_2fempty_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = { - false, false, 753, descriptor_table_protodef_backup_2eproto, "backup.proto", - &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 6, - schemas, file_default_instances, TableStruct_backup_2eproto::offsets, - file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK ::PROTOBUF_NAMESPACE_ID::Metadata -descriptor_table_backup_2eproto_metadata_getter(int index) { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_backup_2eproto); - return descriptor_table_backup_2eproto.file_level_metadata[index]; +bool CreateNewBackupRequest::IsInitialized() const { + return true; +} + +void CreateNewBackupRequest::InternalSwap(CreateNewBackupRequest* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupRequest::GetMetadata() const { + return GetMetadataStatic(); } -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_backup_2eproto(&descriptor_table_backup_2eproto); -namespace backup { // =================================================================== -class ResetKeyRequest::_Internal { +class CreateNewBackupResponse::_Internal { public: }; -ResetKeyRequest::ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) +CreateNewBackupResponse::CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:backup.ResetKeyRequest) + // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupResponse) } -ResetKeyRequest::ResetKeyRequest(const ResetKeyRequest& from) +CreateNewBackupResponse::CreateNewBackupResponse(const CreateNewBackupResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_userid().empty()) { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), - GetArena()); - } clear_has_data(); switch (from.data_case()) { - case kNewKey: { - _internal_set_newkey(from._internal_newkey()); + case kResponseBytes: { + _internal_set_responsebytes(from._internal_responsebytes()); break; } - case kCompactionChunk: { - _internal_set_compactionchunk(from._internal_compactionchunk()); + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); break; } case DATA_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:backup.ResetKeyRequest) + // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupResponse) } -void ResetKeyRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CreateNewBackupResponse::SharedCtor() { clear_has_data(); } -ResetKeyRequest::~ResetKeyRequest() { - // @@protoc_insertion_point(destructor:backup.ResetKeyRequest) +CreateNewBackupResponse::~CreateNewBackupResponse() { + // @@protoc_insertion_point(destructor:backup.CreateNewBackupResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ResetKeyRequest::SharedDtor() { +void CreateNewBackupResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (has_data()) { clear_data(); } } -void ResetKeyRequest::ArenaDtor(void* object) { - ResetKeyRequest* _this = reinterpret_cast< ResetKeyRequest* >(object); +void CreateNewBackupResponse::ArenaDtor(void* object) { + CreateNewBackupResponse* _this = reinterpret_cast< CreateNewBackupResponse* >(object); (void)_this; } -void ResetKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void CreateNewBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void ResetKeyRequest::SetCachedSize(int size) const { +void CreateNewBackupResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } -void ResetKeyRequest::clear_data() { -// @@protoc_insertion_point(one_of_clear_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupResponse) switch (data_case()) { - case kNewKey: { - data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + case kResponseBytes: { + data_.responsebytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } - case kCompactionChunk: { - data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + case kBackupID: { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case DATA_NOT_SET: { @@ -288,46 +1146,37 @@ } -void ResetKeyRequest::Clear() { -// @@protoc_insertion_point(message_clear_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* ResetKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CreateNewBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // bytes responseBytes = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); + auto str = _internal_mutable_responsebytes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.ResetKeyRequest.userId")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes newKey = 2; + // string backupID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_newkey(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes compactionChunk = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_compactionchunk(); + auto str = _internal_mutable_backupid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupResponse.backupID")); CHK_(ptr); } else goto handle_unusual; continue; @@ -353,70 +1202,57 @@ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ResetKeyRequest::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:backup.ResetKeyRequest) + // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "backup.ResetKeyRequest.userId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); - } - - // bytes newKey = 2; - if (_internal_has_newkey()) { + // bytes responseBytes = 1; + if (_internal_has_responsebytes()) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_newkey(), target); + 1, this->_internal_responsebytes(), target); } - // bytes compactionChunk = 3; - if (_internal_has_compactionchunk()) { - target = stream->WriteBytesMaybeAliased( - 3, this->_internal_compactionchunk(), target); + // string backupID = 2; + if (_internal_has_backupid()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_backupid().data(), static_cast(this->_internal_backupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.CreateNewBackupResponse.backupID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_backupid(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:backup.ResetKeyRequest) + // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupResponse) return target; } -size_t ResetKeyRequest::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:backup.ResetKeyRequest) +size_t CreateNewBackupResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupResponse) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userid()); - } - switch (data_case()) { - // bytes newKey = 2; - case kNewKey: { + // bytes responseBytes = 1; + case kResponseBytes: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_newkey()); + this->_internal_responsebytes()); break; } - // bytes compactionChunk = 3; - case kCompactionChunk: { + // string backupID = 2; + case kBackupID: { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_compactionchunk()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); break; } case DATA_NOT_SET: { @@ -432,38 +1268,35 @@ return total_size; } -void ResetKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupResponse) GOOGLE_DCHECK_NE(&from, this); - const ResetKeyRequest* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CreateNewBackupResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.ResetKeyRequest) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.ResetKeyRequest) + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupResponse) MergeFrom(*source); } } -void ResetKeyRequest::MergeFrom(const ResetKeyRequest& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::MergeFrom(const CreateNewBackupResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupResponse) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.userid().size() > 0) { - _internal_set_userid(from._internal_userid()); - } switch (from.data_case()) { - case kNewKey: { - _internal_set_newkey(from._internal_newkey()); + case kResponseBytes: { + _internal_set_responsebytes(from._internal_responsebytes()); break; } - case kCompactionChunk: { - _internal_set_compactionchunk(from._internal_compactionchunk()); + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); break; } case DATA_NOT_SET: { @@ -472,33 +1305,32 @@ } } -void ResetKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupResponse) if (&from == this) return; Clear(); MergeFrom(from); } -void ResetKeyRequest::CopyFrom(const ResetKeyRequest& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:backup.ResetKeyRequest) +void CreateNewBackupResponse::CopyFrom(const CreateNewBackupResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupResponse) if (&from == this) return; Clear(); MergeFrom(from); } -bool ResetKeyRequest::IsInitialized() const { +bool CreateNewBackupResponse::IsInitialized() const { return true; } -void ResetKeyRequest::InternalSwap(ResetKeyRequest* other) { +void CreateNewBackupResponse::InternalSwap(CreateNewBackupResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); swap(data_, other->data_); swap(_oneof_case_[0], other->_oneof_case_[0]); } -::PROTOBUF_NAMESPACE_ID::Metadata ResetKeyRequest::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupResponse::GetMetadata() const { return GetMetadataStatic(); } @@ -507,8 +1339,13 @@ class SendLogRequest::_Internal { public: + static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const SendLogRequest* msg); }; +const ::backup::SimpleAuthenticationRequestData& +SendLogRequest::_Internal::authenticationdata(const SendLogRequest* msg) { + return *msg->authenticationdata_; +} SendLogRequest::SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -518,22 +1355,22 @@ SendLogRequest::SendLogRequest(const SendLogRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_userid().empty()) { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), + logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_logdata().empty()) { + logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logdata(), GetArena()); } - data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_data().empty()) { - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(), - GetArena()); + if (from._internal_has_authenticationdata()) { + authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_); + } else { + authenticationdata_ = nullptr; } // @@protoc_insertion_point(copy_constructor:backup.SendLogRequest) } void SendLogRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +authenticationdata_ = nullptr; } SendLogRequest::~SendLogRequest() { @@ -544,8 +1381,8 @@ void SendLogRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + logdata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete authenticationdata_; } void SendLogRequest::ArenaDtor(void* object) { @@ -564,8 +1401,11 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - data_.ClearToEmpty(); + logdata_.ClearToEmpty(); + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -576,19 +1416,17 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // .backup.SimpleAuthenticationRequestData authenticationData = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userId")); + ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // bytes data = 2; + // bytes logData = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_data(); + auto str = _internal_mutable_logdata(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; @@ -621,20 +1459,18 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "backup.SendLogRequest.userId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::authenticationdata(this), target, stream); } - // bytes data = 2; - if (this->data().size() > 0) { + // bytes logData = 2; + if (this->logdata().size() > 0) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_data(), target); + 2, this->_internal_logdata(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -653,18 +1489,18 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { + // bytes logData = 2; + if (this->logdata().size() > 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userid()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_logdata()); } - // bytes data = 2; - if (this->data().size() > 0) { + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_data()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *authenticationdata_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -698,11 +1534,11 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.userid().size() > 0) { - _internal_set_userid(from._internal_userid()); + if (from.logdata().size() > 0) { + _internal_set_logdata(from._internal_logdata()); } - if (from.data().size() > 0) { - _internal_set_data(from._internal_data()); + if (from.has_authenticationdata()) { + _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata()); } } @@ -727,8 +1563,8 @@ void SendLogRequest::InternalSwap(SendLogRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + logdata_.Swap(&other->logdata_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(authenticationdata_, other->authenticationdata_); } ::PROTOBUF_NAMESPACE_ID::Metadata SendLogRequest::GetMetadata() const { @@ -740,8 +1576,13 @@ class PullBackupKeyRequest::_Internal { public: + static const ::backup::FullAuthenticationRequestData& authenticationdata(const PullBackupKeyRequest* msg); }; +const ::backup::FullAuthenticationRequestData& +PullBackupKeyRequest::_Internal::authenticationdata(const PullBackupKeyRequest* msg) { + return *msg->authenticationdata_; +} PullBackupKeyRequest::PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -751,22 +1592,16 @@ PullBackupKeyRequest::PullBackupKeyRequest(const PullBackupKeyRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_userid().empty()) { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), - GetArena()); - } - pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_pakekey().empty()) { - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakekey(), - GetArena()); + if (from._internal_has_authenticationdata()) { + authenticationdata_ = new ::backup::FullAuthenticationRequestData(*from.authenticationdata_); + } else { + authenticationdata_ = nullptr; } // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyRequest) } void PullBackupKeyRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +authenticationdata_ = nullptr; } PullBackupKeyRequest::~PullBackupKeyRequest() { @@ -777,8 +1612,7 @@ void PullBackupKeyRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - pakekey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete authenticationdata_; } void PullBackupKeyRequest::ArenaDtor(void* object) { @@ -797,8 +1631,10 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - pakekey_.ClearToEmpty(); + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -809,20 +1645,10 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // .backup.FullAuthenticationRequestData authenticationData = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupKeyRequest.userId")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes pakeKey = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_pakekey(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -854,20 +1680,12 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "backup.PullBackupKeyRequest.userId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); - } - - // bytes pakeKey = 2; - if (this->pakekey().size() > 0) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_pakekey(), target); + // .backup.FullAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::authenticationdata(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -886,18 +1704,11 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userid()); - } - - // bytes pakeKey = 2; - if (this->pakekey().size() > 0) { + // .backup.FullAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_pakekey()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *authenticationdata_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -931,11 +1742,8 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.userid().size() > 0) { - _internal_set_userid(from._internal_userid()); - } - if (from.pakekey().size() > 0) { - _internal_set_pakekey(from._internal_pakekey()); + if (from.has_authenticationdata()) { + _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata()); } } @@ -960,8 +1768,7 @@ void PullBackupKeyRequest::InternalSwap(PullBackupKeyRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - pakekey_.Swap(&other->pakekey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(authenticationdata_, other->authenticationdata_); } ::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyRequest::GetMetadata() const { @@ -984,16 +1791,25 @@ PullBackupKeyResponse::PullBackupKeyResponse(const PullBackupKeyResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_encryptedbackupkey().empty()) { - encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_encryptedbackupkey(), - GetArena()); + clear_has_data(); + switch (from.data_case()) { + case kResponseBytes: { + _internal_set_responsebytes(from._internal_responsebytes()); + break; + } + case kEncryptedBackupIDAndKey: { + _internal_set_encryptedbackupidandkey(from._internal_encryptedbackupidandkey()); + break; + } + case DATA_NOT_SET: { + break; + } } // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyResponse) } void PullBackupKeyResponse::SharedCtor() { -encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_data(); } PullBackupKeyResponse::~PullBackupKeyResponse() { @@ -1004,7 +1820,9 @@ void PullBackupKeyResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - encryptedbackupkey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_data()) { + clear_data(); + } } void PullBackupKeyResponse::ArenaDtor(void* object) { @@ -1017,13 +1835,32 @@ _cached_size_.Set(size); } +void PullBackupKeyResponse::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupKeyResponse) + switch (data_case()) { + case kResponseBytes: { + data_.responsebytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kEncryptedBackupIDAndKey: { + data_.encryptedbackupidandkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + void PullBackupKeyResponse::Clear() { // @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - encryptedbackupkey_.ClearToEmpty(); + clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1034,10 +1871,18 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // bytes encryptedBackupKey = 1; + // bytes responseBytes = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_encryptedbackupkey(); + auto str = _internal_mutable_responsebytes(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes encryptedBackupIDAndKey = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_encryptedbackupidandkey(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; @@ -1070,10 +1915,16 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // bytes encryptedBackupKey = 1; - if (this->encryptedbackupkey().size() > 0) { + // bytes responseBytes = 1; + if (_internal_has_responsebytes()) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_responsebytes(), target); + } + + // bytes encryptedBackupIDAndKey = 2; + if (_internal_has_encryptedbackupidandkey()) { target = stream->WriteBytesMaybeAliased( - 1, this->_internal_encryptedbackupkey(), target); + 2, this->_internal_encryptedbackupidandkey(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1092,13 +1943,25 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // bytes encryptedBackupKey = 1; - if (this->encryptedbackupkey().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_encryptedbackupkey()); + switch (data_case()) { + // bytes responseBytes = 1; + case kResponseBytes: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_responsebytes()); + break; + } + // bytes encryptedBackupIDAndKey = 2; + case kEncryptedBackupIDAndKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_encryptedbackupidandkey()); + break; + } + case DATA_NOT_SET: { + break; + } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -1130,8 +1993,18 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.encryptedbackupkey().size() > 0) { - _internal_set_encryptedbackupkey(from._internal_encryptedbackupkey()); + switch (from.data_case()) { + case kResponseBytes: { + _internal_set_responsebytes(from._internal_responsebytes()); + break; + } + case kEncryptedBackupIDAndKey: { + _internal_set_encryptedbackupidandkey(from._internal_encryptedbackupidandkey()); + break; + } + case DATA_NOT_SET: { + break; + } } } @@ -1156,7 +2029,8 @@ void PullBackupKeyResponse::InternalSwap(PullBackupKeyResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - encryptedbackupkey_.Swap(&other->encryptedbackupkey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyResponse::GetMetadata() const { @@ -1168,8 +2042,13 @@ class PullCompactionRequest::_Internal { public: + static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const PullCompactionRequest* msg); }; +const ::backup::SimpleAuthenticationRequestData& +PullCompactionRequest::_Internal::authenticationdata(const PullCompactionRequest* msg) { + return *msg->authenticationdata_; +} PullCompactionRequest::PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1179,22 +2058,16 @@ PullCompactionRequest::PullCompactionRequest(const PullCompactionRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_userid().empty()) { - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), - GetArena()); - } - message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_message().empty()) { - message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(), - GetArena()); + if (from._internal_has_authenticationdata()) { + authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_); + } else { + authenticationdata_ = nullptr; } // @@protoc_insertion_point(copy_constructor:backup.PullCompactionRequest) } void PullCompactionRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +authenticationdata_ = nullptr; } PullCompactionRequest::~PullCompactionRequest() { @@ -1205,8 +2078,7 @@ void PullCompactionRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete authenticationdata_; } void PullCompactionRequest::ArenaDtor(void* object) { @@ -1225,8 +2097,10 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - message_.ClearToEmpty(); + if (GetArena() == nullptr && authenticationdata_ != nullptr) { + delete authenticationdata_; + } + authenticationdata_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1237,20 +2111,10 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // .backup.SimpleAuthenticationRequestData authenticationData = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.userId")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes message = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_message(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1282,20 +2146,12 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "backup.PullCompactionRequest.userId"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); - } - - // bytes message = 2; - if (this->message().size() > 0) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_message(), target); + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::authenticationdata(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1314,18 +2170,11 @@ // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_userid()); - } - - // bytes message = 2; - if (this->message().size() > 0) { + // .backup.SimpleAuthenticationRequestData authenticationData = 1; + if (this->has_authenticationdata()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_message()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *authenticationdata_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1359,11 +2208,8 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.userid().size() > 0) { - _internal_set_userid(from._internal_userid()); - } - if (from.message().size() > 0) { - _internal_set_message(from._internal_message()); + if (from.has_authenticationdata()) { + _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata()); } } @@ -1388,8 +2234,7 @@ void PullCompactionRequest::InternalSwap(PullCompactionRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(authenticationdata_, other->authenticationdata_); } ::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionRequest::GetMetadata() const { @@ -1662,8 +2507,17 @@ // @@protoc_insertion_point(namespace_scope) } // namespace backup PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::backup::ResetKeyRequest* Arena::CreateMaybeMessage< ::backup::ResetKeyRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::ResetKeyRequest >(arena); +template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::FullAuthenticationRequestData >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::SimpleAuthenticationRequestData >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::SimpleAuthenticationRequestData >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage< ::backup::CreateNewBackupRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::CreateNewBackupRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage< ::backup::CreateNewBackupResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::CreateNewBackupResponse >(arena); } template<> PROTOBUF_NOINLINE ::backup::SendLogRequest* Arena::CreateMaybeMessage< ::backup::SendLogRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::backup::SendLogRequest >(arena); diff --git a/native/cpp/CommonCpp/grpc/protos/backup.proto b/native/cpp/CommonCpp/grpc/protos/backup.proto --- a/native/cpp/CommonCpp/grpc/protos/backup.proto +++ b/native/cpp/CommonCpp/grpc/protos/backup.proto @@ -5,45 +5,65 @@ import "google/protobuf/empty.proto"; service BackupService { - rpc ResetKey(stream ResetKeyRequest) returns (google.protobuf.Empty) {} - rpc SendLog(SendLogRequest) returns (google.protobuf.Empty) {} - rpc PullBackupKey(PullBackupKeyRequest) returns (PullBackupKeyResponse) {} - rpc PullCompaction(PullCompactionRequest) returns (stream PullCompactionResponse) {} + rpc CreateNewBackup(stream CreateNewBackupRequest) returns (stream CreateNewBackupResponse) {} + rpc SendLog(stream SendLogRequest) returns (google.protobuf.Empty) {} + rpc PullBackupKey(stream PullBackupKeyRequest) returns (stream PullBackupKeyResponse) {} + rpc PullCompaction(stream PullCompactionRequest) returns (stream PullCompactionResponse) {} } -// ResetKey +// Helper types -message ResetKeyRequest { - string userId = 1; +message FullAuthenticationRequestData { + bytes requestBytes = 1; + string userID = 2; +} + +message SimpleAuthenticationRequestData { + string backupID = 1; + string userID = 2; +} + +// CreateNewBackup + +message CreateNewBackupRequest { oneof data { - bytes newKey = 2; - bytes compactionChunk = 3; + FullAuthenticationRequestData authenticationData = 1; + bytes newEncryptedKey = 2; + bytes newCompactionChunk = 3; + } +} + +message CreateNewBackupResponse { + oneof data { + bytes responseBytes = 1; + string backupID = 2; } } // SendLog message SendLogRequest { - string userId = 1; - bytes data = 2; + SimpleAuthenticationRequestData authenticationData = 1; + bytes logData = 2; } // PullBackupKey message PullBackupKeyRequest { - string userId = 1; - bytes pakeKey = 2; + FullAuthenticationRequestData authenticationData = 1; } message PullBackupKeyResponse { - bytes encryptedBackupKey = 1; + oneof data { + bytes responseBytes = 1; + bytes encryptedBackupIDAndKey = 2; + } } // PullCompaction message PullCompactionRequest { - string userId = 1; - bytes message = 2; + SimpleAuthenticationRequestData authenticationData = 1; } message PullCompactionResponse {