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[7] 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,12 @@ 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 PullBackupKeyRequest; struct PullBackupKeyRequestDefaultTypeInternal; extern PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_; @@ -68,43 +74,41 @@ 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_; } // namespace backup PROTOBUF_NAMESPACE_OPEN +template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*); +template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(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*); PROTOBUF_NAMESPACE_CLOSE namespace backup { // =================================================================== -class ResetKeyRequest PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.ResetKeyRequest) */ { +class CreateNewBackupRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupRequest) */ { public: - inline ResetKeyRequest() : ResetKeyRequest(nullptr) {} - virtual ~ResetKeyRequest(); - explicit constexpr ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline CreateNewBackupRequest() : CreateNewBackupRequest(nullptr) {} + virtual ~CreateNewBackupRequest(); + explicit constexpr CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - ResetKeyRequest(const ResetKeyRequest& from); - ResetKeyRequest(ResetKeyRequest&& from) noexcept - : ResetKeyRequest() { + CreateNewBackupRequest(const CreateNewBackupRequest& from); + CreateNewBackupRequest(CreateNewBackupRequest&& from) noexcept + : CreateNewBackupRequest() { *this = ::std::move(from); } - inline ResetKeyRequest& operator=(const ResetKeyRequest& from) { + inline CreateNewBackupRequest& operator=(const CreateNewBackupRequest& from) { CopyFrom(from); return *this; } - inline ResetKeyRequest& operator=(ResetKeyRequest&& from) noexcept { + inline CreateNewBackupRequest& operator=(CreateNewBackupRequest&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -122,26 +126,28 @@ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const ResetKeyRequest& default_instance() { + static const CreateNewBackupRequest& default_instance() { return *internal_default_instance(); } enum DataCase { - kNewKey = 2, - kCompactionChunk = 3, + kRequestBytes = 1, + kUserID = 2, + kNewEncryptedKey = 3, + kNewCompactionChunk = 4, DATA_NOT_SET = 0, }; - static inline const ResetKeyRequest* internal_default_instance() { - return reinterpret_cast( - &_ResetKeyRequest_default_instance_); + static inline const CreateNewBackupRequest* internal_default_instance() { + return reinterpret_cast( + &_CreateNewBackupRequest_default_instance_); } static constexpr int kIndexInFileMessages = 0; - friend void swap(ResetKeyRequest& a, ResetKeyRequest& b) { + friend void swap(CreateNewBackupRequest& a, CreateNewBackupRequest& b) { a.Swap(&b); } - inline void Swap(ResetKeyRequest* other) { + inline void Swap(CreateNewBackupRequest* 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(CreateNewBackupRequest* 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 CreateNewBackupRequest* New() const final { + return CreateMaybeMessage(nullptr); } - ResetKeyRequest* 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 ResetKeyRequest& from); - void MergeFrom(const ResetKeyRequest& from); + void CopyFrom(const CreateNewBackupRequest& from); + void MergeFrom(const CreateNewBackupRequest& 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(CreateNewBackupRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "backup.ResetKeyRequest"; + return "backup.CreateNewBackupRequest"; } protected: - explicit ResetKeyRequest(::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); @@ -206,11 +212,36 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kNewKeyFieldNumber = 2, - kCompactionChunkFieldNumber = 3, + kRequestBytesFieldNumber = 1, + kUserIDFieldNumber = 2, + kNewEncryptedKeyFieldNumber = 3, + kNewCompactionChunkFieldNumber = 4, }; - // string userId = 1; + // bytes requestBytes = 1; + bool has_requestbytes() const; + private: + bool _internal_has_requestbytes() const; + public: + 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; + bool has_userid() const; + private: + bool _internal_has_userid() const; + public: void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -226,53 +257,55 @@ std::string* _internal_mutable_userid(); public: - // bytes newKey = 2; - bool has_newkey() const; + // bytes newEncryptedKey = 3; + bool has_newencryptedkey() const; private: - bool _internal_has_newkey() const; + bool _internal_has_newencryptedkey() 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); + 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_newkey() const; - void _internal_set_newkey(const std::string& value); - std::string* _internal_mutable_newkey(); + const std::string& _internal_newencryptedkey() const; + void _internal_set_newencryptedkey(const std::string& value); + std::string* _internal_mutable_newencryptedkey(); public: - // bytes compactionChunk = 3; - bool has_compactionchunk() const; + // bytes newCompactionChunk = 4; + bool has_newcompactionchunk() const; private: - bool _internal_has_compactionchunk() const; + bool _internal_has_newcompactionchunk() 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); + 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_compactionchunk() const; - void _internal_set_compactionchunk(const std::string& value); - std::string* _internal_mutable_compactionchunk(); + 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.ResetKeyRequest) + // @@protoc_insertion_point(class_scope:backup.CreateNewBackupRequest) private: class _Internal; - void set_has_newkey(); - void set_has_compactionchunk(); + void set_has_requestbytes(); + void set_has_userid(); + void set_has_newencryptedkey(); + void set_has_newcompactionchunk(); inline bool has_data() const; inline void clear_has_data(); @@ -280,12 +313,202 @@ template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::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_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestbytes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; + ::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 CreateNewBackupResponse PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupResponse) */ { + public: + inline CreateNewBackupResponse() : CreateNewBackupResponse(nullptr) {} + virtual ~CreateNewBackupResponse(); + explicit constexpr CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CreateNewBackupResponse(const CreateNewBackupResponse& from); + CreateNewBackupResponse(CreateNewBackupResponse&& from) noexcept + : CreateNewBackupResponse() { + *this = ::std::move(from); + } + + inline CreateNewBackupResponse& operator=(const CreateNewBackupResponse& from) { + CopyFrom(from); + return *this; + } + inline CreateNewBackupResponse& operator=(CreateNewBackupResponse&& 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 CreateNewBackupResponse& default_instance() { + return *internal_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 = + 1; + + friend void swap(CreateNewBackupResponse& a, CreateNewBackupResponse& b) { + a.Swap(&b); + } + inline void Swap(CreateNewBackupResponse* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CreateNewBackupResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CreateNewBackupResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + 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 CreateNewBackupResponse& from); + void MergeFrom(const CreateNewBackupResponse& 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(CreateNewBackupResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.CreateNewBackupResponse"; + } + protected: + explicit CreateNewBackupResponse(::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, + kBackupIDFieldNumber = 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: + + // 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_; + 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]; @@ -332,12 +555,19 @@ static const SendLogRequest& default_instance() { return *internal_default_instance(); } + enum DataCase { + kBackupID = 1, + kUserID = 2, + kLogData = 3, + DATA_NOT_SET = 0, + }; + static inline const SendLogRequest* internal_default_instance() { return reinterpret_cast( &_SendLogRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 1; + 2; friend void swap(SendLogRequest& a, SendLogRequest& b) { a.Swap(&b); @@ -407,10 +637,35 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kDataFieldNumber = 2, + kBackupIDFieldNumber = 1, + kUserIDFieldNumber = 2, + kLogDataFieldNumber = 3, }; - // string userId = 1; + // string backupID = 1; + 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: + + // string userID = 2; + bool has_userid() const; + private: + bool _internal_has_userid() const; + public: void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -426,32 +681,51 @@ 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); + // bytes logData = 3; + bool has_logdata() const; + private: + bool _internal_has_logdata() const; + public: + 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_data() const; - void _internal_set_data(const std::string& value); - std::string* _internal_mutable_data(); + const std::string& _internal_logdata() const; + void _internal_set_logdata(const std::string& value); + std::string* _internal_mutable_logdata(); public: + void clear_data(); + DataCase data_case() const; // @@protoc_insertion_point(class_scope:backup.SendLogRequest) private: class _Internal; + void set_has_backupid(); + void set_has_userid(); + void set_has_logdata(); + + 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 data_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logdata_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- @@ -494,12 +768,19 @@ static const PullBackupKeyRequest& default_instance() { return *internal_default_instance(); } + enum DataCase { + kRequestBytes = 1, + kUserID = 2, + kBackupCreated = 3, + DATA_NOT_SET = 0, + }; + static inline const PullBackupKeyRequest* internal_default_instance() { return reinterpret_cast( &_PullBackupKeyRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 2; + 3; friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) { a.Swap(&b); @@ -569,10 +850,35 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kPakeKeyFieldNumber = 2, + kRequestBytesFieldNumber = 1, + kUserIDFieldNumber = 2, + kBackupCreatedFieldNumber = 3, }; - // string userId = 1; + // bytes requestBytes = 1; + bool has_requestbytes() const; + private: + bool _internal_has_requestbytes() const; + public: + 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; + bool has_userid() const; + private: + bool _internal_has_userid() const; + public: void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -588,32 +894,51 @@ std::string* _internal_mutable_userid(); public: - // 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); + // string backupCreated = 3; + bool has_backupcreated() const; + private: + bool _internal_has_backupcreated() const; + public: + void clear_backupcreated(); + const std::string& backupcreated() const; + void set_backupcreated(const std::string& value); + void set_backupcreated(std::string&& value); + void set_backupcreated(const char* value); + void set_backupcreated(const char* value, size_t size); + std::string* mutable_backupcreated(); + std::string* release_backupcreated(); + void set_allocated_backupcreated(std::string* backupcreated); private: - const std::string& _internal_pakekey() const; - void _internal_set_pakekey(const std::string& value); - std::string* _internal_mutable_pakekey(); + const std::string& _internal_backupcreated() const; + void _internal_set_backupcreated(const std::string& value); + std::string* _internal_mutable_backupcreated(); public: + void clear_data(); + DataCase data_case() const; // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest) private: class _Internal; + void set_has_requestbytes(); + void set_has_userid(); + void set_has_backupcreated(); + + 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_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestbytes_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupcreated_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- @@ -656,12 +981,18 @@ 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 = - 3; + 4; friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) { a.Swap(&b); @@ -731,33 +1062,72 @@ // accessors ------------------------------------------------------- enum : int { - kEncryptedBackupKeyFieldNumber = 1, + kResponseBytesFieldNumber = 1, + kEncryptedBackupIDAndKeyFieldNumber = 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: + 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_encryptedbackupkey() const; - void _internal_set_encryptedbackupkey(const std::string& value); - std::string* _internal_mutable_encryptedbackupkey(); + 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_; - ::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 encryptedbackupidandkey_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- @@ -800,12 +1170,18 @@ static const PullCompactionRequest& default_instance() { return *internal_default_instance(); } + enum DataCase { + kBackupID = 1, + kUserID = 2, + DATA_NOT_SET = 0, + }; + static inline const PullCompactionRequest* internal_default_instance() { return reinterpret_cast( &_PullCompactionRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 4; + 5; friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) { a.Swap(&b); @@ -875,10 +1251,34 @@ // accessors ------------------------------------------------------- enum : int { - kUserIdFieldNumber = 1, - kMessageFieldNumber = 2, + kBackupIDFieldNumber = 1, + kUserIDFieldNumber = 2, }; - // string userId = 1; + // string backupID = 1; + 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: + + // string userID = 2; + bool has_userid() const; + private: + bool _internal_has_userid() const; + public: void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); @@ -894,32 +1294,29 @@ std::string* _internal_mutable_userid(); 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); - private: - const std::string& _internal_message() const; - void _internal_set_message(const std::string& value); - std::string* _internal_mutable_message(); - public: - + void clear_data(); + DataCase data_case() const; // @@protoc_insertion_point(class_scope:backup.PullCompactionRequest) private: class _Internal; + void set_has_backupid(); + void set_has_userid(); + + 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 message_; + union DataUnion { + constexpr DataUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; + } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + friend struct ::TableStruct_backup_2eproto; }; // ------------------------------------------------------------------- @@ -973,7 +1370,7 @@ &_PullCompactionResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 6; friend void swap(PullCompactionResponse& a, PullCompactionResponse& b) { a.Swap(&b); @@ -1120,741 +1517,1842 @@ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ -// ResetKeyRequest +// CreateNewBackupRequest -// string userId = 1; -inline void ResetKeyRequest::clear_userid() { - userid_.ClearToEmpty(); +// bytes requestBytes = 1; +inline bool CreateNewBackupRequest::_internal_has_requestbytes() const { + return data_case() == kRequestBytes; } -inline const std::string& ResetKeyRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.userId) - return _internal_userid(); -} -inline void ResetKeyRequest::set_userid(const std::string& value) { - _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.userId) +inline bool CreateNewBackupRequest::has_requestbytes() const { + return _internal_has_requestbytes(); } -inline std::string* ResetKeyRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.userId) - return _internal_mutable_userid(); +inline void CreateNewBackupRequest::set_has_requestbytes() { + _oneof_case_[0] = kRequestBytes; } -inline const std::string& ResetKeyRequest::_internal_userid() const { - return userid_.Get(); +inline void CreateNewBackupRequest::clear_requestbytes() { + if (_internal_has_requestbytes()) { + data_.requestbytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& CreateNewBackupRequest::requestbytes() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.requestBytes) + return _internal_requestbytes(); +} +inline void CreateNewBackupRequest::set_requestbytes(const std::string& value) { + _internal_set_requestbytes(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.requestBytes) +} +inline std::string* CreateNewBackupRequest::mutable_requestbytes() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.requestBytes) + return _internal_mutable_requestbytes(); +} +inline const std::string& CreateNewBackupRequest::_internal_requestbytes() const { + if (_internal_has_requestbytes()) { + return data_.requestbytes_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupRequest::_internal_set_requestbytes(const std::string& value) { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupRequest::set_requestbytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.requestBytes) + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.requestBytes) +} +inline void CreateNewBackupRequest::set_requestbytes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.requestBytes) +} +inline void CreateNewBackupRequest::set_requestbytes(const void* value, + size_t size) { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.requestBytes) +} +inline std::string* CreateNewBackupRequest::_internal_mutable_requestbytes() { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.requestbytes_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* CreateNewBackupRequest::release_requestbytes() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.requestBytes) + if (_internal_has_requestbytes()) { + clear_has_data(); + return data_.requestbytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupRequest::set_allocated_requestbytes(std::string* requestbytes) { + if (has_data()) { + clear_data(); + } + if (requestbytes != nullptr) { + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(requestbytes); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(requestbytes); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.requestBytes) +} + +// string userID = 2; +inline bool CreateNewBackupRequest::_internal_has_userid() const { + return data_case() == kUserID; +} +inline bool CreateNewBackupRequest::has_userid() const { + return _internal_has_userid(); +} +inline void CreateNewBackupRequest::set_has_userid() { + _oneof_case_[0] = kUserID; +} +inline void CreateNewBackupRequest::clear_userid() { + if (_internal_has_userid()) { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& CreateNewBackupRequest::userid() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.userID) + return _internal_userid(); +} +inline void CreateNewBackupRequest::set_userid(const std::string& value) { + _internal_set_userid(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.userID) +} +inline std::string* CreateNewBackupRequest::mutable_userid() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.userID) + return _internal_mutable_userid(); +} +inline const std::string& CreateNewBackupRequest::_internal_userid() const { + if (_internal_has_userid()) { + return data_.userid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupRequest::_internal_set_userid(const std::string& value) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupRequest::set_userid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.userID) + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.userID) +} +inline void CreateNewBackupRequest::set_userid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.userID) +} +inline void CreateNewBackupRequest::set_userid(const char* value, + size_t size) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.userID) +} +inline std::string* CreateNewBackupRequest::_internal_mutable_userid() { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.userid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* CreateNewBackupRequest::release_userid() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.userID) + if (_internal_has_userid()) { + clear_has_data(); + return data_.userid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupRequest::set_allocated_userid(std::string* userid) { + if (has_data()) { + clear_data(); + } + if (userid != nullptr) { + set_has_userid(); + data_.userid_.UnsafeSetDefault(userid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(userid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.userID) +} + +// bytes newEncryptedKey = 3; +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 = 4; +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]); +} +// ------------------------------------------------------------------- + +// CreateNewBackupResponse + +// bytes responseBytes = 1; +inline bool CreateNewBackupResponse::_internal_has_responsebytes() const { + return data_case() == kResponseBytes; +} +inline bool CreateNewBackupResponse::has_responsebytes() const { + return _internal_has_responsebytes(); +} +inline void CreateNewBackupResponse::set_has_responsebytes() { + _oneof_case_[0] = kResponseBytes; +} +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& CreateNewBackupResponse::responsebytes() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.responseBytes) + return _internal_responsebytes(); +} +inline void CreateNewBackupResponse::set_responsebytes(const std::string& value) { + _internal_set_responsebytes(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.responseBytes) +} +inline std::string* CreateNewBackupResponse::mutable_responsebytes() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.responseBytes) + return _internal_mutable_responsebytes(); +} +inline const std::string& CreateNewBackupResponse::_internal_responsebytes() const { + if (_internal_has_responsebytes()) { + return data_.responsebytes_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupResponse::_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 CreateNewBackupResponse::set_responsebytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.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.CreateNewBackupResponse.responseBytes) +} +inline void CreateNewBackupResponse::set_responsebytes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + 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.CreateNewBackupResponse.responseBytes) +} +inline void CreateNewBackupResponse::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.CreateNewBackupResponse.responseBytes) +} +inline std::string* CreateNewBackupResponse::_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 std::string* CreateNewBackupResponse::release_responsebytes() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.responseBytes) + if (_internal_has_responsebytes()) { + clear_has_data(); + return data_.responsebytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupResponse::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.CreateNewBackupResponse.responseBytes) +} + +// string backupID = 2; +inline bool CreateNewBackupResponse::_internal_has_backupid() const { + return data_case() == kBackupID; +} +inline bool CreateNewBackupResponse::has_backupid() const { + return _internal_has_backupid(); +} +inline void CreateNewBackupResponse::set_has_backupid() { + _oneof_case_[0] = kBackupID; +} +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& CreateNewBackupResponse::backupid() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.backupID) + return _internal_backupid(); +} +inline void CreateNewBackupResponse::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID) +} +inline std::string* CreateNewBackupResponse::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.backupID) + return _internal_mutable_backupid(); +} +inline const std::string& CreateNewBackupResponse::_internal_backupid() const { + if (_internal_has_backupid()) { + return data_.backupid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupResponse::_internal_set_backupid(const std::string& value) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupResponse::set_backupid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID) + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.backupID) +} +inline void CreateNewBackupResponse::set_backupid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.backupID) +} +inline void CreateNewBackupResponse::set_backupid(const char* value, + size_t size) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.backupID) +} +inline std::string* CreateNewBackupResponse::_internal_mutable_backupid() { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.backupid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* CreateNewBackupResponse::release_backupid() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.backupID) + if (_internal_has_backupid()) { + clear_has_data(); + return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void CreateNewBackupResponse::set_allocated_backupid(std::string* backupid) { + if (has_data()) { + clear_data(); + } + if (backupid != nullptr) { + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(backupid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(backupid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.backupID) +} + +inline bool CreateNewBackupResponse::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void CreateNewBackupResponse::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; +} +inline CreateNewBackupResponse::DataCase CreateNewBackupResponse::data_case() const { + return CreateNewBackupResponse::DataCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// SendLogRequest + +// string backupID = 1; +inline bool SendLogRequest::_internal_has_backupid() const { + return data_case() == kBackupID; +} +inline bool SendLogRequest::has_backupid() const { + return _internal_has_backupid(); +} +inline void SendLogRequest::set_has_backupid() { + _oneof_case_[0] = kBackupID; +} +inline void SendLogRequest::clear_backupid() { + if (_internal_has_backupid()) { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& SendLogRequest::backupid() const { + // @@protoc_insertion_point(field_get:backup.SendLogRequest.backupID) + return _internal_backupid(); +} +inline void SendLogRequest::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.SendLogRequest.backupID) +} +inline std::string* SendLogRequest::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.backupID) + return _internal_mutable_backupid(); +} +inline const std::string& SendLogRequest::_internal_backupid() const { + if (_internal_has_backupid()) { + return data_.backupid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void SendLogRequest::_internal_set_backupid(const std::string& value) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void SendLogRequest::set_backupid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.SendLogRequest.backupID) + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.backupID) +} +inline void SendLogRequest::set_backupid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.backupID) +} +inline void SendLogRequest::set_backupid(const char* value, + size_t size) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.backupID) +} +inline std::string* SendLogRequest::_internal_mutable_backupid() { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.backupid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SendLogRequest::release_backupid() { + // @@protoc_insertion_point(field_release:backup.SendLogRequest.backupID) + if (_internal_has_backupid()) { + clear_has_data(); + return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void SendLogRequest::set_allocated_backupid(std::string* backupid) { + if (has_data()) { + clear_data(); + } + if (backupid != nullptr) { + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(backupid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(backupid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.backupID) +} + +// string userID = 2; +inline bool SendLogRequest::_internal_has_userid() const { + return data_case() == kUserID; +} +inline bool SendLogRequest::has_userid() const { + return _internal_has_userid(); +} +inline void SendLogRequest::set_has_userid() { + _oneof_case_[0] = kUserID; +} +inline void SendLogRequest::clear_userid() { + if (_internal_has_userid()) { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +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 std::string* SendLogRequest::mutable_userid() { + // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userID) + return _internal_mutable_userid(); +} +inline const std::string& SendLogRequest::_internal_userid() const { + if (_internal_has_userid()) { + return data_.userid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void SendLogRequest::_internal_set_userid(const std::string& value) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void SendLogRequest::set_userid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.SendLogRequest.userID) + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.userID) +} +inline void SendLogRequest::set_userid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.userID) +} +inline void SendLogRequest::set_userid(const char* value, + size_t size) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.userID) +} +inline std::string* SendLogRequest::_internal_mutable_userid() { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.userid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SendLogRequest::release_userid() { + // @@protoc_insertion_point(field_release:backup.SendLogRequest.userID) + if (_internal_has_userid()) { + clear_has_data(); + return data_.userid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void SendLogRequest::set_allocated_userid(std::string* userid) { + if (has_data()) { + clear_data(); + } + if (userid != nullptr) { + set_has_userid(); + data_.userid_.UnsafeSetDefault(userid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(userid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userID) +} + +// bytes logData = 3; +inline bool SendLogRequest::_internal_has_logdata() const { + return data_case() == kLogData; +} +inline bool SendLogRequest::has_logdata() const { + return _internal_has_logdata(); +} +inline void SendLogRequest::set_has_logdata() { + _oneof_case_[0] = kLogData; +} +inline void SendLogRequest::clear_logdata() { + if (_internal_has_logdata()) { + data_.logdata_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& SendLogRequest::logdata() const { + // @@protoc_insertion_point(field_get:backup.SendLogRequest.logData) + return _internal_logdata(); +} +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_logdata() { + // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.logData) + return _internal_mutable_logdata(); +} +inline const std::string& SendLogRequest::_internal_logdata() const { + if (_internal_has_logdata()) { + return data_.logdata_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void SendLogRequest::_internal_set_logdata(const std::string& value) { + if (!_internal_has_logdata()) { + clear_data(); + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void SendLogRequest::set_logdata(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.SendLogRequest.logData) + if (!_internal_has_logdata()) { + clear_data(); + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.logdata_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.logData) +} +inline void SendLogRequest::set_logdata(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_logdata()) { + clear_data(); + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + 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_logdata(const void* value, + size_t size) { + if (!_internal_has_logdata()) { + clear_data(); + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.logdata_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.logData) +} +inline std::string* SendLogRequest::_internal_mutable_logdata() { + if (!_internal_has_logdata()) { + clear_data(); + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.logdata_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SendLogRequest::release_logdata() { + // @@protoc_insertion_point(field_release:backup.SendLogRequest.logData) + if (_internal_has_logdata()) { + clear_has_data(); + return data_.logdata_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void SendLogRequest::set_allocated_logdata(std::string* logdata) { + if (has_data()) { + clear_data(); + } + if (logdata != nullptr) { + set_has_logdata(); + data_.logdata_.UnsafeSetDefault(logdata); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(logdata); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.logData) +} + +inline bool SendLogRequest::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void SendLogRequest::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; +} +inline SendLogRequest::DataCase SendLogRequest::data_case() const { + return SendLogRequest::DataCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// PullBackupKeyRequest + +// bytes requestBytes = 1; +inline bool PullBackupKeyRequest::_internal_has_requestbytes() const { + return data_case() == kRequestBytes; +} +inline bool PullBackupKeyRequest::has_requestbytes() const { + return _internal_has_requestbytes(); +} +inline void PullBackupKeyRequest::set_has_requestbytes() { + _oneof_case_[0] = kRequestBytes; +} +inline void PullBackupKeyRequest::clear_requestbytes() { + if (_internal_has_requestbytes()) { + data_.requestbytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& PullBackupKeyRequest::requestbytes() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.requestBytes) + return _internal_requestbytes(); +} +inline void PullBackupKeyRequest::set_requestbytes(const std::string& value) { + _internal_set_requestbytes(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.requestBytes) +} +inline std::string* PullBackupKeyRequest::mutable_requestbytes() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.requestBytes) + return _internal_mutable_requestbytes(); +} +inline const std::string& PullBackupKeyRequest::_internal_requestbytes() const { + if (_internal_has_requestbytes()) { + return data_.requestbytes_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupKeyRequest::_internal_set_requestbytes(const std::string& value) { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupKeyRequest::set_requestbytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.requestBytes) + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.requestBytes) +} +inline void PullBackupKeyRequest::set_requestbytes(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.requestBytes) +} +inline void PullBackupKeyRequest::set_requestbytes(const void* value, + size_t size) { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.requestbytes_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.requestBytes) } -inline void ResetKeyRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline std::string* PullBackupKeyRequest::_internal_mutable_requestbytes() { + if (!_internal_has_requestbytes()) { + clear_data(); + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.requestbytes_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* PullBackupKeyRequest::release_requestbytes() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.requestBytes) + if (_internal_has_requestbytes()) { + clear_has_data(); + return data_.requestbytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void PullBackupKeyRequest::set_allocated_requestbytes(std::string* requestbytes) { + if (has_data()) { + clear_data(); + } + if (requestbytes != nullptr) { + set_has_requestbytes(); + data_.requestbytes_.UnsafeSetDefault(requestbytes); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(requestbytes); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.requestBytes) +} + +// string userID = 2; +inline bool PullBackupKeyRequest::_internal_has_userid() const { + return data_case() == kUserID; +} +inline bool PullBackupKeyRequest::has_userid() const { + return _internal_has_userid(); +} +inline void PullBackupKeyRequest::set_has_userid() { + _oneof_case_[0] = kUserID; +} +inline void PullBackupKeyRequest::clear_userid() { + if (_internal_has_userid()) { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +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 { + if (_internal_has_userid()) { + return data_.userid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void PullBackupKeyRequest::_internal_set_userid(const std::string& value) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void PullBackupKeyRequest::set_userid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.userID) + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.userID) +} +inline void PullBackupKeyRequest::set_userid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.userID) +} +inline void PullBackupKeyRequest::set_userid(const char* value, + size_t size) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.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 std::string* PullBackupKeyRequest::_internal_mutable_userid() { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.userid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline void ResetKeyRequest::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) +inline std::string* PullBackupKeyRequest::release_userid() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userID) + if (_internal_has_userid()) { + clear_has_data(); + return data_.userid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } } -inline void ResetKeyRequest::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) -} -inline void ResetKeyRequest::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) -} -inline std::string* ResetKeyRequest::_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) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void ResetKeyRequest::set_allocated_userid(std::string* userid) { +inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) { + if (has_data()) { + clear_data(); + } if (userid != nullptr) { - - } else { - + set_has_userid(); + data_.userid_.UnsafeSetDefault(userid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(userid); + } } - 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.PullBackupKeyRequest.userID) } -// bytes newKey = 2; -inline bool ResetKeyRequest::_internal_has_newkey() const { - return data_case() == kNewKey; +// string backupCreated = 3; +inline bool PullBackupKeyRequest::_internal_has_backupcreated() const { + return data_case() == kBackupCreated; } -inline bool ResetKeyRequest::has_newkey() const { - return _internal_has_newkey(); +inline bool PullBackupKeyRequest::has_backupcreated() const { + return _internal_has_backupcreated(); } -inline void ResetKeyRequest::set_has_newkey() { - _oneof_case_[0] = kNewKey; +inline void PullBackupKeyRequest::set_has_backupcreated() { + _oneof_case_[0] = kBackupCreated; } -inline void ResetKeyRequest::clear_newkey() { - if (_internal_has_newkey()) { - data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void PullBackupKeyRequest::clear_backupcreated() { + if (_internal_has_backupcreated()) { + data_.backupcreated_.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& PullBackupKeyRequest::backupcreated() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.backupCreated) + return _internal_backupcreated(); } -inline void ResetKeyRequest::set_newkey(const std::string& value) { - _internal_set_newkey(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey) +inline void PullBackupKeyRequest::set_backupcreated(const std::string& value) { + _internal_set_backupcreated(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.backupCreated) } -inline std::string* ResetKeyRequest::mutable_newkey() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.newKey) - return _internal_mutable_newkey(); +inline std::string* PullBackupKeyRequest::mutable_backupcreated() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.backupCreated) + return _internal_mutable_backupcreated(); } -inline const std::string& ResetKeyRequest::_internal_newkey() const { - if (_internal_has_newkey()) { - return data_.newkey_.Get(); +inline const std::string& PullBackupKeyRequest::_internal_backupcreated() const { + if (_internal_has_backupcreated()) { + return data_.backupcreated_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void ResetKeyRequest::_internal_set_newkey(const std::string& value) { - if (!_internal_has_newkey()) { +inline void PullBackupKeyRequest::_internal_set_backupcreated(const std::string& value) { + if (!_internal_has_backupcreated()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + data_.backupcreated_.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 PullBackupKeyRequest::set_backupcreated(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.backupCreated) + if (!_internal_has_backupcreated()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set( + data_.backupcreated_.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.PullBackupKeyRequest.backupCreated) } -inline void ResetKeyRequest::set_newkey(const char* value) { +inline void PullBackupKeyRequest::set_backupcreated(const char* value) { GOOGLE_DCHECK(value != nullptr); - if (!_internal_has_newkey()) { + if (!_internal_has_backupcreated()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + data_.backupcreated_.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.PullBackupKeyRequest.backupCreated) } -inline void ResetKeyRequest::set_newkey(const void* value, +inline void PullBackupKeyRequest::set_backupcreated(const char* value, size_t size) { - if (!_internal_has_newkey()) { + if (!_internal_has_backupcreated()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.newkey_.Set( + data_.backupcreated_.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.PullBackupKeyRequest.backupCreated) } -inline std::string* ResetKeyRequest::_internal_mutable_newkey() { - if (!_internal_has_newkey()) { +inline std::string* PullBackupKeyRequest::_internal_mutable_backupcreated() { + if (!_internal_has_backupcreated()) { clear_data(); - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return data_.newkey_.Mutable( + return data_.backupcreated_.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* PullBackupKeyRequest::release_backupcreated() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.backupCreated) + if (_internal_has_backupcreated()) { clear_has_data(); - return data_.newkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return data_.backupcreated_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } -inline void ResetKeyRequest::set_allocated_newkey(std::string* newkey) { +inline void PullBackupKeyRequest::set_allocated_backupcreated(std::string* backupcreated) { if (has_data()) { clear_data(); } - if (newkey != nullptr) { - set_has_newkey(); - data_.newkey_.UnsafeSetDefault(newkey); + if (backupcreated != nullptr) { + set_has_backupcreated(); + data_.backupcreated_.UnsafeSetDefault(backupcreated); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(newkey); + arena->Own(backupcreated); } } - // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.newKey) + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.backupCreated) } -// bytes compactionChunk = 3; -inline bool ResetKeyRequest::_internal_has_compactionchunk() const { - return data_case() == kCompactionChunk; +inline bool PullBackupKeyRequest::has_data() const { + return data_case() != DATA_NOT_SET; } -inline bool ResetKeyRequest::has_compactionchunk() const { - return _internal_has_compactionchunk(); +inline void PullBackupKeyRequest::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; } -inline void ResetKeyRequest::set_has_compactionchunk() { - _oneof_case_[0] = kCompactionChunk; +inline PullBackupKeyRequest::DataCase PullBackupKeyRequest::data_case() const { + return PullBackupKeyRequest::DataCase(_oneof_case_[0]); } -inline void ResetKeyRequest::clear_compactionchunk() { - if (_internal_has_compactionchunk()) { - data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +// ------------------------------------------------------------------- + +// PullBackupKeyResponse + +// bytes responseBytes = 1; +inline bool PullBackupKeyResponse::_internal_has_responsebytes() const { + return data_case() == kResponseBytes; +} +inline bool PullBackupKeyResponse::has_responsebytes() const { + return _internal_has_responsebytes(); +} +inline void PullBackupKeyResponse::set_has_responsebytes() { + _oneof_case_[0] = kResponseBytes; +} +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& ResetKeyRequest::compactionchunk() const { - // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.compactionChunk) - return _internal_compactionchunk(); +inline const std::string& PullBackupKeyResponse::responsebytes() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.responseBytes) + return _internal_responsebytes(); } -inline void ResetKeyRequest::set_compactionchunk(const std::string& value) { - _internal_set_compactionchunk(value); - // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk) +inline void PullBackupKeyResponse::set_responsebytes(const std::string& value) { + _internal_set_responsebytes(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.responseBytes) } -inline std::string* ResetKeyRequest::mutable_compactionchunk() { - // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.compactionChunk) - return _internal_mutable_compactionchunk(); +inline std::string* PullBackupKeyResponse::mutable_responsebytes() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.responseBytes) + return _internal_mutable_responsebytes(); } -inline const std::string& ResetKeyRequest::_internal_compactionchunk() const { - if (_internal_has_compactionchunk()) { - return data_.compactionchunk_.Get(); +inline const std::string& PullBackupKeyResponse::_internal_responsebytes() const { + if (_internal_has_responsebytes()) { + return data_.responsebytes_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void ResetKeyRequest::_internal_set_compactionchunk(const std::string& value) { - if (!_internal_has_compactionchunk()) { +inline void PullBackupKeyResponse::_internal_set_responsebytes(const std::string& value) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + data_.responsebytes_.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 PullBackupKeyResponse::set_responsebytes(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.responseBytes) + if (!_internal_has_responsebytes()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.Set( + data_.responsebytes_.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.PullBackupKeyResponse.responseBytes) } -inline void ResetKeyRequest::set_compactionchunk(const char* value) { +inline void PullBackupKeyResponse::set_responsebytes(const char* value) { GOOGLE_DCHECK(value != nullptr); - if (!_internal_has_compactionchunk()) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.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.compactionChunk) + // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.responseBytes) } -inline void ResetKeyRequest::set_compactionchunk(const void* value, +inline void PullBackupKeyResponse::set_responsebytes(const void* value, size_t size) { - if (!_internal_has_compactionchunk()) { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.compactionchunk_.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.compactionChunk) + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.responseBytes) } -inline std::string* ResetKeyRequest::_internal_mutable_compactionchunk() { - if (!_internal_has_compactionchunk()) { +inline std::string* PullBackupKeyResponse::_internal_mutable_responsebytes() { + if (!_internal_has_responsebytes()) { clear_data(); - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return data_.compactionchunk_.Mutable( + return data_.responsebytes_.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* PullBackupKeyResponse::release_responsebytes() { + // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.responseBytes) + if (_internal_has_responsebytes()) { clear_has_data(); - return data_.compactionchunk_.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_compactionchunk(std::string* compactionchunk) { +inline void PullBackupKeyResponse::set_allocated_responsebytes(std::string* responsebytes) { if (has_data()) { clear_data(); } - if (compactionchunk != nullptr) { - set_has_compactionchunk(); - data_.compactionchunk_.UnsafeSetDefault(compactionchunk); + if (responsebytes != nullptr) { + set_has_responsebytes(); + data_.responsebytes_.UnsafeSetDefault(responsebytes); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(compactionchunk); + arena->Own(responsebytes); } } - // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.compactionChunk) + // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.responseBytes) } -inline bool ResetKeyRequest::has_data() const { - return data_case() != DATA_NOT_SET; +// bytes encryptedBackupIDAndKey = 2; +inline bool PullBackupKeyResponse::_internal_has_encryptedbackupidandkey() const { + return data_case() == kEncryptedBackupIDAndKey; } -inline void ResetKeyRequest::clear_has_data() { - _oneof_case_[0] = DATA_NOT_SET; +inline bool PullBackupKeyResponse::has_encryptedbackupidandkey() const { + return _internal_has_encryptedbackupidandkey(); } -inline ResetKeyRequest::DataCase ResetKeyRequest::data_case() const { - return ResetKeyRequest::DataCase(_oneof_case_[0]); +inline void PullBackupKeyResponse::set_has_encryptedbackupidandkey() { + _oneof_case_[0] = kEncryptedBackupIDAndKey; } -// ------------------------------------------------------------------- - -// SendLogRequest - -// string userId = 1; -inline void SendLogRequest::clear_userid() { - userid_.ClearToEmpty(); +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& SendLogRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.SendLogRequest.userId) - return _internal_userid(); +inline const std::string& PullBackupKeyResponse::encryptedbackupidandkey() const { + // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + return _internal_encryptedbackupidandkey(); } -inline void SendLogRequest::set_userid(const std::string& value) { - _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.SendLogRequest.userId) +inline void PullBackupKeyResponse::set_encryptedbackupidandkey(const std::string& value) { + _internal_set_encryptedbackupidandkey(value); + // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline std::string* SendLogRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userId) - return _internal_mutable_userid(); +inline std::string* PullBackupKeyResponse::mutable_encryptedbackupidandkey() { + // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) + return _internal_mutable_encryptedbackupidandkey(); } -inline const std::string& SendLogRequest::_internal_userid() const { - return userid_.Get(); +inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupidandkey() const { + if (_internal_has_encryptedbackupidandkey()) { + return data_.encryptedbackupidandkey_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void SendLogRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +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 SendLogRequest::set_userid(std::string&& value) { - - userid_.Set( +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.SendLogRequest.userId) + // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline void SendLogRequest::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.SendLogRequest.userId) -} -inline void SendLogRequest::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.SendLogRequest.userId) -} -inline std::string* SendLogRequest::_internal_mutable_userid() { - - 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()); + 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 void SendLogRequest::set_allocated_userid(std::string* userid) { - if (userid != nullptr) { - - } else { - +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()); } - userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, + data_.encryptedbackupidandkey_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userId) -} - -// bytes data = 2; -inline void SendLogRequest::clear_data() { - data_.ClearToEmpty(); -} -inline const std::string& SendLogRequest::data() const { - // @@protoc_insertion_point(field_get:backup.SendLogRequest.data) - return _internal_data(); + // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupIDAndKey) } -inline void SendLogRequest::set_data(const std::string& value) { - _internal_set_data(value); - // @@protoc_insertion_point(field_set:backup.SendLogRequest.data) +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 std::string* SendLogRequest::mutable_data() { - // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.data) - return _internal_mutable_data(); +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; + } } -inline const std::string& SendLogRequest::_internal_data() const { - return data_.Get(); +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) } -inline void SendLogRequest::_internal_set_data(const std::string& value) { - - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + +inline bool PullBackupKeyResponse::has_data() const { + return data_case() != DATA_NOT_SET; } -inline void SendLogRequest::set_data(std::string&& value) { - - data_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.data) +inline void PullBackupKeyResponse::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; } -inline void SendLogRequest::set_data(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) -} -inline void SendLogRequest::set_data(const void* value, - size_t size) { - - data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.data) -} -inline std::string* SendLogRequest::_internal_mutable_data() { - - return data_.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 void SendLogRequest::set_allocated_data(std::string* data) { - if (data != nullptr) { - - } else { - - } - data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.data) +inline PullBackupKeyResponse::DataCase PullBackupKeyResponse::data_case() const { + return PullBackupKeyResponse::DataCase(_oneof_case_[0]); } - // ------------------------------------------------------------------- -// PullBackupKeyRequest +// PullCompactionRequest -// 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) -} -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 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) +// string backupID = 1; +inline bool PullCompactionRequest::_internal_has_backupid() const { + return data_case() == kBackupID; } -inline std::string* PullBackupKeyRequest::_internal_mutable_userid() { - - return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline bool PullCompactionRequest::has_backupid() const { + return _internal_has_backupid(); } -inline std::string* PullBackupKeyRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userId) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline void PullCompactionRequest::set_has_backupid() { + _oneof_case_[0] = kBackupID; } -inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) { - if (userid != nullptr) { - - } else { - +inline void PullCompactionRequest::clear_backupid() { + if (_internal_has_backupid()) { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); } - 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 const std::string& PullCompactionRequest::backupid() const { + // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.backupID) + return _internal_backupid(); } -inline void PullBackupKeyRequest::set_pakekey(const std::string& value) { - _internal_set_pakekey(value); - // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.pakeKey) +inline void PullCompactionRequest::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.backupID) } -inline std::string* PullBackupKeyRequest::mutable_pakekey() { - // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.pakeKey) - return _internal_mutable_pakekey(); +inline std::string* PullCompactionRequest::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.backupID) + return _internal_mutable_backupid(); } -inline const std::string& PullBackupKeyRequest::_internal_pakekey() const { - return pakekey_.Get(); +inline const std::string& PullCompactionRequest::_internal_backupid() const { + if (_internal_has_backupid()) { + return data_.backupid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void PullBackupKeyRequest::_internal_set_pakekey(const std::string& value) { - - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline void PullCompactionRequest::_internal_set_backupid(const std::string& value) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void PullBackupKeyRequest::set_pakekey(std::string&& value) { - - pakekey_.Set( +inline void PullCompactionRequest::set_backupid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.backupID) + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.pakeKey) + // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.backupID) } -inline void PullBackupKeyRequest::set_pakekey(const char* value) { +inline void PullCompactionRequest::set_backupid(const char* value) { GOOGLE_DCHECK(value != nullptr); - - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.pakeKey) -} -inline void PullBackupKeyRequest::set_pakekey(const void* value, - size_t size) { - - pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.pakeKey) -} -inline std::string* PullBackupKeyRequest::_internal_mutable_pakekey() { - - 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) { - - } else { - + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - pakekey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakekey, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.pakeKey) -} - -// ------------------------------------------------------------------- - -// PullBackupKeyResponse - -// bytes encryptedBackupKey = 1; -inline void PullBackupKeyResponse::clear_encryptedbackupkey() { - encryptedbackupkey_.ClearToEmpty(); + data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.backupID) } -inline const std::string& PullBackupKeyResponse::encryptedbackupkey() const { - // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupKey) - return _internal_encryptedbackupkey(); +inline void PullCompactionRequest::set_backupid(const char* value, + size_t size) { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.backupID) } -inline void PullBackupKeyResponse::set_encryptedbackupkey(const std::string& value) { - _internal_set_encryptedbackupkey(value); - // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupKey) +inline std::string* PullCompactionRequest::_internal_mutable_backupid() { + if (!_internal_has_backupid()) { + clear_data(); + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.backupid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* PullBackupKeyResponse::mutable_encryptedbackupkey() { - // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupKey) - return _internal_mutable_encryptedbackupkey(); +inline std::string* PullCompactionRequest::release_backupid() { + // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.backupID) + if (_internal_has_backupid()) { + clear_has_data(); + return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } } -inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupkey() const { - return encryptedbackupkey_.Get(); +inline void PullCompactionRequest::set_allocated_backupid(std::string* backupid) { + if (has_data()) { + clear_data(); + } + if (backupid != nullptr) { + set_has_backupid(); + data_.backupid_.UnsafeSetDefault(backupid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(backupid); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.backupID) } -inline void PullBackupKeyResponse::_internal_set_encryptedbackupkey(const std::string& value) { - - encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + +// string userID = 2; +inline bool PullCompactionRequest::_internal_has_userid() const { + return data_case() == kUserID; } -inline void PullBackupKeyResponse::set_encryptedbackupkey(std::string&& value) { - - encryptedbackupkey_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupKey) +inline bool PullCompactionRequest::has_userid() const { + return _internal_has_userid(); } -inline void PullBackupKeyResponse::set_encryptedbackupkey(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) -} -inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupkey() { - - return encryptedbackupkey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* PullBackupKeyResponse::release_encryptedbackupkey() { - // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupKey) - return encryptedbackupkey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void PullBackupKeyResponse::set_allocated_encryptedbackupkey(std::string* encryptedbackupkey) { - if (encryptedbackupkey != nullptr) { - - } else { - - } - encryptedbackupkey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryptedbackupkey, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupKey) +inline void PullCompactionRequest::set_has_userid() { + _oneof_case_[0] = kUserID; } - -// ------------------------------------------------------------------- - -// PullCompactionRequest - -// string userId = 1; inline void PullCompactionRequest::clear_userid() { - userid_.ClearToEmpty(); + if (_internal_has_userid()) { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } } inline const std::string& PullCompactionRequest::userid() const { - // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userId) + // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userID) return _internal_userid(); } inline void PullCompactionRequest::set_userid(const std::string& value) { _internal_set_userid(value); - // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userId) + // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userID) } inline std::string* PullCompactionRequest::mutable_userid() { - // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userId) + // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userID) return _internal_mutable_userid(); } inline const std::string& PullCompactionRequest::_internal_userid() const { - return userid_.Get(); + if (_internal_has_userid()) { + return data_.userid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } inline void PullCompactionRequest::_internal_set_userid(const std::string& value) { - - userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void PullCompactionRequest::set_userid(std::string&& value) { - - userid_.Set( + // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userID) + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.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.PullCompactionRequest.userID) } inline void PullCompactionRequest::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.PullCompactionRequest.userId) + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.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) + size_t size) { + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.userID) } inline std::string* PullCompactionRequest::_internal_mutable_userid() { - - return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + if (!_internal_has_userid()) { + clear_data(); + set_has_userid(); + data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.userid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* PullCompactionRequest::release_userid() { - // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userId) - return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userID) + if (_internal_has_userid()) { + clear_has_data(); + return data_.userid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } } inline void PullCompactionRequest::set_allocated_userid(std::string* userid) { + if (has_data()) { + clear_data(); + } if (userid != nullptr) { - - } else { - + set_has_userid(); + data_.userid_.UnsafeSetDefault(userid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(userid); + } } - userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userId) + // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userID) } -// bytes message = 2; -inline void PullCompactionRequest::clear_message() { - message_.ClearToEmpty(); -} -inline const std::string& PullCompactionRequest::message() const { - // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.message) - return _internal_message(); -} -inline void PullCompactionRequest::set_message(const std::string& value) { - _internal_set_message(value); - // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.message) -} -inline std::string* PullCompactionRequest::mutable_message() { - // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.message) - return _internal_mutable_message(); -} -inline const std::string& PullCompactionRequest::_internal_message() const { - return message_.Get(); -} -inline void PullCompactionRequest::_internal_set_message(const std::string& value) { - - message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline bool PullCompactionRequest::has_data() const { + return data_case() != DATA_NOT_SET; } -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 void PullCompactionRequest::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; } -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 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 std::string* PullCompactionRequest::_internal_mutable_message() { - - return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* PullCompactionRequest::release_message() { - // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.message) - return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void PullCompactionRequest::set_allocated_message(std::string* message) { - if (message != nullptr) { - - } else { - - } - message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.message) +inline PullCompactionRequest::DataCase PullCompactionRequest::data_case() const { + return PullCompactionRequest::DataCase(_oneof_case_[0]); } - // ------------------------------------------------------------------- // PullCompactionResponse @@ -2101,6 +3599,8 @@ // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@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,33 @@ PROTOBUF_PRAGMA_INIT_SEG namespace backup { -constexpr ResetKeyRequest::ResetKeyRequest( +constexpr CreateNewBackupRequest::CreateNewBackupRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , _oneof_case_{}{} -struct ResetKeyRequestDefaultTypeInternal { - constexpr ResetKeyRequestDefaultTypeInternal() + : _oneof_case_{}{} +struct CreateNewBackupRequestDefaultTypeInternal { + constexpr CreateNewBackupRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ResetKeyRequestDefaultTypeInternal() {} + ~CreateNewBackupRequestDefaultTypeInternal() {} union { - ResetKeyRequest _instance; + CreateNewBackupRequest _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_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){} + : _oneof_case_{}{} struct SendLogRequestDefaultTypeInternal { constexpr SendLogRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -45,8 +55,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){} + : _oneof_case_{}{} struct PullBackupKeyRequestDefaultTypeInternal { constexpr PullBackupKeyRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -58,7 +67,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 +79,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){} + : _oneof_case_{}{} struct PullCompactionRequestDefaultTypeInternal { constexpr PullCompactionRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -94,47 +102,63 @@ }; 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[7]; 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::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_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_ + PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, userid_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _internal_metadata_), ~0u, // no _extensions_ - ~0u, // no _oneof_case_ + PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, userid_), - PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, pakekey_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, data_), ~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_ + PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, userid_), - PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, message_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _internal_metadata_), ~0u, // no _extensions_ @@ -145,16 +169,18 @@ 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::CreateNewBackupRequest)}, + { 10, -1, sizeof(::backup::CreateNewBackupResponse)}, + { 18, -1, sizeof(::backup::SendLogRequest)}, + { 27, -1, sizeof(::backup::PullBackupKeyRequest)}, + { 36, -1, sizeof(::backup::PullBackupKeyResponse)}, + { 44, -1, sizeof(::backup::PullCompactionRequest)}, + { 52, -1, sizeof(::backup::PullCompactionResponse)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::backup::_ResetKeyRequest_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_), @@ -164,32 +190,40 @@ 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" + "empty.proto\"\203\001\n\026CreateNewBackupRequest\022\026" + "\n\014requestBytes\030\001 \001(\014H\000\022\020\n\006userID\030\002 \001(\tH\000" + "\022\031\n\017newEncryptedKey\030\003 \001(\014H\000\022\034\n\022newCompac" + "tionChunk\030\004 \001(\014H\000B\006\n\004data\"N\n\027CreateNewBa" + "ckupResponse\022\027\n\rresponseBytes\030\001 \001(\014H\000\022\022\n" + "\010backupID\030\002 \001(\tH\000B\006\n\004data\"Q\n\016SendLogRequ" + "est\022\022\n\010backupID\030\001 \001(\tH\000\022\020\n\006userID\030\002 \001(\tH" + "\000\022\021\n\007logData\030\003 \001(\014H\000B\006\n\004data\"a\n\024PullBack" + "upKeyRequest\022\026\n\014requestBytes\030\001 \001(\014H\000\022\020\n\006" + "userID\030\002 \001(\tH\000\022\027\n\rbackupCreated\030\003 \001(\tH\000B" + "\006\n\004data\"[\n\025PullBackupKeyResponse\022\027\n\rresp" + "onseBytes\030\001 \001(\014H\000\022!\n\027encryptedBackupIDAn" + "dKey\030\002 \001(\014H\000B\006\n\004data\"E\n\025PullCompactionRe" + "quest\022\022\n\010backupID\030\001 \001(\tH\000\022\020\n\006userID\030\002 \001(" + "\tH\000B\006\n\004data\"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\017Create" + "NewBackup\022\036.backup.CreateNewBackupReques" + "t\032\037.backup.CreateNewBackupResponse\"\000(\0010\001" + "\022=\n\007SendLog\022\026.backup.SendLogRequest\032\026.go" + "ogle.protobuf.Empty\"\000(\001\022R\n\rPullBackupKey" + "\022\034.backup.PullBackupKeyRequest\032\035.backup." + "PullBackupKeyResponse\"\000(\0010\001\022U\n\016PullCompa" + "ction\022\035.backup.PullCompactionRequest\032\036.b" + "ackup.PullCompactionResponse\"\000(\0010\001b\006prot" + "o3" ; 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, + false, false, 1042, descriptor_table_protodef_backup_2eproto, "backup.proto", + &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 7, 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, }; @@ -205,79 +239,88 @@ // =================================================================== -class ResetKeyRequest::_Internal { +class CreateNewBackupRequest::_Internal { public: }; -ResetKeyRequest::ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) +CreateNewBackupRequest::CreateNewBackupRequest(::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.CreateNewBackupRequest) } -ResetKeyRequest::ResetKeyRequest(const ResetKeyRequest& from) +CreateNewBackupRequest::CreateNewBackupRequest(const CreateNewBackupRequest& 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 kRequestBytes: { + _internal_set_requestbytes(from._internal_requestbytes()); break; } - case kCompactionChunk: { - _internal_set_compactionchunk(from._internal_compactionchunk()); + case kUserID: { + _internal_set_userid(from._internal_userid()); + 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.ResetKeyRequest) + // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupRequest) } -void ResetKeyRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CreateNewBackupRequest::SharedCtor() { clear_has_data(); } -ResetKeyRequest::~ResetKeyRequest() { - // @@protoc_insertion_point(destructor:backup.ResetKeyRequest) +CreateNewBackupRequest::~CreateNewBackupRequest() { + // @@protoc_insertion_point(destructor:backup.CreateNewBackupRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ResetKeyRequest::SharedDtor() { +void CreateNewBackupRequest::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 CreateNewBackupRequest::ArenaDtor(void* object) { + CreateNewBackupRequest* _this = reinterpret_cast< CreateNewBackupRequest* >(object); (void)_this; } -void ResetKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void CreateNewBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void ResetKeyRequest::SetCachedSize(int size) const { +void CreateNewBackupRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } -void ResetKeyRequest::clear_data() { -// @@protoc_insertion_point(one_of_clear_start:backup.ResetKeyRequest) +void CreateNewBackupRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupRequest) switch (data_case()) { - case kNewKey: { - data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + case kRequestBytes: { + data_.requestbytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } - case kCompactionChunk: { - data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + case kUserID: { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + 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: { @@ -288,45 +331,52 @@ } -void ResetKeyRequest::Clear() { -// @@protoc_insertion_point(message_clear_start:backup.ResetKeyRequest) +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; - 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* 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) { - // string userId = 1; + // bytes requestBytes = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); + auto str = _internal_mutable_requestbytes(); 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 userID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_newkey(); + auto str = _internal_mutable_userid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupRequest.userID")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes compactionChunk = 3; + // bytes newEncryptedKey = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_compactionchunk(); + auto str = _internal_mutable_newencryptedkey(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes newCompactionChunk = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_newcompactionchunk(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; @@ -353,70 +403,83 @@ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ResetKeyRequest::_InternalSerialize( +::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.ResetKeyRequest) + // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { + // bytes requestBytes = 1; + if (_internal_has_requestbytes()) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_requestbytes(), target); + } + + // string userID = 2; + if (_internal_has_userid()) { ::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"); + "backup.CreateNewBackupRequest.userID"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); + 2, this->_internal_userid(), target); } - // bytes newKey = 2; - if (_internal_has_newkey()) { + // bytes newEncryptedKey = 3; + if (_internal_has_newencryptedkey()) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_newkey(), target); + 3, this->_internal_newencryptedkey(), target); } - // bytes compactionChunk = 3; - if (_internal_has_compactionchunk()) { + // bytes newCompactionChunk = 4; + if (_internal_has_newcompactionchunk()) { target = stream->WriteBytesMaybeAliased( - 3, this->_internal_compactionchunk(), target); + 4, 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.ResetKeyRequest) + // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupRequest) return target; } -size_t ResetKeyRequest::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:backup.ResetKeyRequest) +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; - // 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 requestBytes = 1; + case kRequestBytes: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_newkey()); + this->_internal_requestbytes()); break; } - // bytes compactionChunk = 3; - case kCompactionChunk: { + // string userID = 2; + case kUserID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + break; + } + // bytes newEncryptedKey = 3; + case kNewEncryptedKey: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_compactionchunk()); + this->_internal_newencryptedkey()); + break; + } + // bytes newCompactionChunk = 4; + case kNewCompactionChunk: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_newcompactionchunk()); break; } case DATA_NOT_SET: { @@ -432,73 +495,344 @@ return total_size; } -void ResetKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:backup.ResetKeyRequest) +void CreateNewBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupRequest) GOOGLE_DCHECK_NE(&from, this); - const ResetKeyRequest* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CreateNewBackupRequest* 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.CreateNewBackupRequest) ::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.CreateNewBackupRequest) MergeFrom(*source); } } -void ResetKeyRequest::MergeFrom(const ResetKeyRequest& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:backup.ResetKeyRequest) +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; - if (from.userid().size() > 0) { - _internal_set_userid(from._internal_userid()); + switch (from.data_case()) { + case kRequestBytes: { + _internal_set_requestbytes(from._internal_requestbytes()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + 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); +} + +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(); +} + + +// =================================================================== + +class CreateNewBackupResponse::_Internal { + public: +}; + +CreateNewBackupResponse::CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupResponse) +} +CreateNewBackupResponse::CreateNewBackupResponse(const CreateNewBackupResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + 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.CreateNewBackupResponse) +} + +void CreateNewBackupResponse::SharedCtor() { +clear_has_data(); } -void ResetKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:backup.ResetKeyRequest) +CreateNewBackupResponse::~CreateNewBackupResponse() { + // @@protoc_insertion_point(destructor:backup.CreateNewBackupResponse) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void CreateNewBackupResponse::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_data()) { + clear_data(); + } +} + +void CreateNewBackupResponse::ArenaDtor(void* object) { + CreateNewBackupResponse* _this = reinterpret_cast< CreateNewBackupResponse* >(object); + (void)_this; +} +void CreateNewBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void CreateNewBackupResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void CreateNewBackupResponse::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupResponse) + switch (data_case()) { + case kResponseBytes: { + data_.responsebytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kBackupID: { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + +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; + + clear_data(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +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) { + // bytes responseBytes = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_responsebytes(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string backupID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + 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; + 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* CreateNewBackupResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes responseBytes = 1; + if (_internal_has_responsebytes()) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_responsebytes(), 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.CreateNewBackupResponse) + return target; +} + +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; + + switch (data_case()) { + // bytes responseBytes = 1; + case kResponseBytes: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_responsebytes()); + break; + } + // string backupID = 2; + case kBackupID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + 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 CreateNewBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupResponse) + GOOGLE_DCHECK_NE(&from, this); + const CreateNewBackupResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@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.CreateNewBackupResponse) + MergeFrom(*source); + } +} + +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; + + switch (from.data_case()) { + case kResponseBytes: { + _internal_set_responsebytes(from._internal_responsebytes()); + break; + } + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case DATA_NOT_SET: { + break; + } + } +} + +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(); } @@ -518,22 +852,29 @@ 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(), - 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()); + clear_has_data(); + switch (from.data_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case kLogData: { + _internal_set_logdata(from._internal_logdata()); + break; + } + case DATA_NOT_SET: { + break; + } } // @@protoc_insertion_point(copy_constructor:backup.SendLogRequest) } void SendLogRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_data(); } SendLogRequest::~SendLogRequest() { @@ -544,8 +885,9 @@ void SendLogRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_data()) { + clear_data(); + } } void SendLogRequest::ArenaDtor(void* object) { @@ -558,14 +900,36 @@ _cached_size_.Set(size); } +void SendLogRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.SendLogRequest) + switch (data_case()) { + case kBackupID: { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUserID: { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kLogData: { + data_.logdata_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + void SendLogRequest::Clear() { // @@protoc_insertion_point(message_clear_start:backup.SendLogRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - data_.ClearToEmpty(); + clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -576,19 +940,28 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // string backupID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); + auto str = _internal_mutable_backupid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userId")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.backupID")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes data = 2; + // string userID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_data(); + auto str = _internal_mutable_userid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes logData = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_logdata(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; @@ -621,20 +994,30 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { + // string backupID = 1; + 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.SendLogRequest.backupID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_backupid(), target); + } + + // string userID = 2; + if (_internal_has_userid()) { ::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"); + "backup.SendLogRequest.userID"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); + 2, this->_internal_userid(), target); } - // bytes data = 2; - if (this->data().size() > 0) { + // bytes logData = 3; + if (_internal_has_logdata()) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_data(), target); + 3, this->_internal_logdata(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -653,20 +1036,32 @@ // 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 data = 2; - if (this->data().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_data()); + switch (data_case()) { + // string backupID = 1; + case kBackupID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + break; + } + // string userID = 2; + case kUserID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + break; + } + // bytes logData = 3; + case kLogData: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_logdata()); + 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_); @@ -698,11 +1093,22 @@ ::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.data().size() > 0) { - _internal_set_data(from._internal_data()); + switch (from.data_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case kLogData: { + _internal_set_logdata(from._internal_logdata()); + break; + } + case DATA_NOT_SET: { + break; + } } } @@ -727,8 +1133,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()); + swap(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata SendLogRequest::GetMetadata() const { @@ -751,22 +1157,29 @@ 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()); + clear_has_data(); + switch (from.data_case()) { + case kRequestBytes: { + _internal_set_requestbytes(from._internal_requestbytes()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case kBackupCreated: { + _internal_set_backupcreated(from._internal_backupcreated()); + break; + } + case DATA_NOT_SET: { + break; + } } // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyRequest) } void PullBackupKeyRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_data(); } PullBackupKeyRequest::~PullBackupKeyRequest() { @@ -777,8 +1190,9 @@ void PullBackupKeyRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - pakekey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_data()) { + clear_data(); + } } void PullBackupKeyRequest::ArenaDtor(void* object) { @@ -791,14 +1205,36 @@ _cached_size_.Set(size); } +void PullBackupKeyRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupKeyRequest) + switch (data_case()) { + case kRequestBytes: { + data_.requestbytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUserID: { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kBackupCreated: { + data_.backupcreated_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + void PullBackupKeyRequest::Clear() { // @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - pakekey_.ClearToEmpty(); + clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -809,20 +1245,29 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // bytes requestBytes = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); + auto str = _internal_mutable_requestbytes(); 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; + // string userID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_pakekey(); + 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; + // string backupCreated = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_backupcreated(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupKeyRequest.backupCreated")); CHK_(ptr); } else goto handle_unusual; continue; @@ -854,20 +1299,30 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { + // bytes requestBytes = 1; + if (_internal_has_requestbytes()) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_requestbytes(), target); + } + + // string userID = 2; + if (_internal_has_userid()) { ::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"); + "backup.PullBackupKeyRequest.userID"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); + 2, this->_internal_userid(), target); } - // bytes pakeKey = 2; - if (this->pakekey().size() > 0) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_pakekey(), target); + // string backupCreated = 3; + if (_internal_has_backupcreated()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_backupcreated().data(), static_cast(this->_internal_backupcreated().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.PullBackupKeyRequest.backupCreated"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_backupcreated(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -886,20 +1341,32 @@ // 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) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_pakekey()); + switch (data_case()) { + // bytes requestBytes = 1; + case kRequestBytes: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_requestbytes()); + break; + } + // string userID = 2; + case kUserID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + break; + } + // string backupCreated = 3; + case kBackupCreated: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupcreated()); + 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_); @@ -931,11 +1398,22 @@ ::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()); + switch (from.data_case()) { + case kRequestBytes: { + _internal_set_requestbytes(from._internal_requestbytes()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case kBackupCreated: { + _internal_set_backupcreated(from._internal_backupcreated()); + break; + } + case DATA_NOT_SET: { + break; + } } } @@ -960,8 +1438,8 @@ 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(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyRequest::GetMetadata() const { @@ -984,16 +1462,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 +1491,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 +1506,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 +1542,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 +1586,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 +1614,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 +1664,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 +1700,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 { @@ -1179,22 +1724,25 @@ 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()); + clear_has_data(); + switch (from.data_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case DATA_NOT_SET: { + break; + } } // @@protoc_insertion_point(copy_constructor:backup.PullCompactionRequest) } void PullCompactionRequest::SharedCtor() { -userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_data(); } PullCompactionRequest::~PullCompactionRequest() { @@ -1205,8 +1753,9 @@ void PullCompactionRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_data()) { + clear_data(); + } } void PullCompactionRequest::ArenaDtor(void* object) { @@ -1219,14 +1768,32 @@ _cached_size_.Set(size); } +void PullCompactionRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.PullCompactionRequest) + switch (data_case()) { + case kBackupID: { + data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUserID: { + data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + void PullCompactionRequest::Clear() { // @@protoc_insertion_point(message_clear_start:backup.PullCompactionRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - userid_.ClearToEmpty(); - message_.ClearToEmpty(); + clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1237,20 +1804,21 @@ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string userId = 1; + // string backupID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_userid(); + auto str = _internal_mutable_backupid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.userId")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.backupID")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes message = 2; + // string userID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_message(); + 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; @@ -1282,20 +1850,24 @@ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string userId = 1; - if (this->userid().size() > 0) { + // string backupID = 1; + if (_internal_has_backupid()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_userid().data(), static_cast(this->_internal_userid().length()), + this->_internal_backupid().data(), static_cast(this->_internal_backupid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "backup.PullCompactionRequest.userId"); + "backup.PullCompactionRequest.backupID"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_userid(), target); + 1, this->_internal_backupid(), target); } - // bytes message = 2; - if (this->message().size() > 0) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_message(), target); + // string userID = 2; + if (_internal_has_userid()) { + ::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( + 2, this->_internal_userid(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1314,20 +1886,25 @@ // 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) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_message()); + switch (data_case()) { + // string backupID = 1; + case kBackupID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + break; + } + // string userID = 2; + case kUserID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_userid()); + 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_); @@ -1359,11 +1936,18 @@ ::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()); + switch (from.data_case()) { + case kBackupID: { + _internal_set_backupid(from._internal_backupid()); + break; + } + case kUserID: { + _internal_set_userid(from._internal_userid()); + break; + } + case DATA_NOT_SET: { + break; + } } } @@ -1388,8 +1972,8 @@ 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(data_, other->data_); + swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionRequest::GetMetadata() const { @@ -1662,8 +2246,11 @@ // @@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::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,64 @@ 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 +// CreateNewBackup -message ResetKeyRequest { - string userId = 1; +message CreateNewBackupRequest { oneof data { - bytes newKey = 2; - bytes compactionChunk = 3; + bytes requestBytes = 1; + string userID = 2; + bytes newEncryptedKey = 3; + bytes newCompactionChunk = 4; + } +} + +message CreateNewBackupResponse { + oneof data { + bytes responseBytes = 1; + string backupID = 2; } } // SendLog message SendLogRequest { - string userId = 1; - bytes data = 2; + oneof data { + string backupID = 1; + string userID = 2; + bytes logData = 3; + } } // PullBackupKey message PullBackupKeyRequest { - string userId = 1; - bytes pakeKey = 2; + oneof data { + bytes requestBytes = 1; + string userID = 2; + string backupCreated = 3; + } } message PullBackupKeyResponse { - bytes encryptedBackupKey = 1; + oneof data { + bytes responseBytes = 1; + bytes encryptedBackupIDAndKey = 2; + } } // PullCompaction message PullCompactionRequest { - string userId = 1; - bytes message = 2; + oneof data { + string backupID = 1; + string userID = 2; + } } message PullCompactionResponse {