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 @@ -57,13 +57,13 @@ 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)); } - std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response) { return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>>(SendLogRaw(context, response)); } - std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq)); } std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) { @@ -84,13 +84,23 @@ std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, request, cq)); } + std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::AddAttachmentRequest>> AddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::AddAttachmentRequest>>(AddAttachmentRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>> AsyncAddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>>(AsyncAddAttachmentRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>> PrepareAsyncAddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>>(PrepareAsyncAddAttachmentRaw(context, response, cq)); + } class async_interface { public: virtual ~async_interface() {} 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 SendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) = 0; virtual void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) = 0; virtual void PullBackup(::grpc::ClientContext* context, const ::backup::PullBackupRequest* request, ::grpc::ClientReadReactor< ::backup::PullBackupResponse>* reactor) = 0; + virtual void AddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::AddAttachmentRequest>* reactor) = 0; }; typedef class async_interface experimental_async_interface; virtual class async_interface* async() { return nullptr; } @@ -99,15 +109,18 @@ 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::ClientWriterInterface< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< ::backup::AddAttachmentRequest>* AddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>* AsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< ::backup::AddAttachmentRequest>* PrepareAsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: @@ -121,13 +134,13 @@ 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::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response) { return std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>>(SendLogRaw(context, response)); } - std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag)); } - std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq)); } std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) { @@ -148,13 +161,23 @@ std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, request, cq)); } + std::unique_ptr< ::grpc::ClientWriter< ::backup::AddAttachmentRequest>> AddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return std::unique_ptr< ::grpc::ClientWriter< ::backup::AddAttachmentRequest>>(AddAttachmentRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>> AsyncAddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>>(AsyncAddAttachmentRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>> PrepareAsyncAddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>>(PrepareAsyncAddAttachmentRaw(context, response, cq)); + } class async final : public StubInterface::async_interface { public: 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 SendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) override; void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) override; void PullBackup(::grpc::ClientContext* context, const ::backup::PullBackupRequest* request, ::grpc::ClientReadReactor< ::backup::PullBackupResponse>* reactor) override; + void AddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::AddAttachmentRequest>* reactor) override; private: friend class Stub; explicit async(Stub* stub): stub_(stub) { } @@ -169,19 +192,23 @@ ::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::ClientWriter< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response) override; + ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKeyRaw(::grpc::ClientContext* context) override; ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request) override; ::grpc::ClientAsyncReader< ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, const ::backup::PullBackupRequest& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< ::backup::AddAttachmentRequest>* AddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override; + ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>* AsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>* PrepareAsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_CreateNewBackup_; const ::grpc::internal::RpcMethod rpcmethod_SendLog_; const ::grpc::internal::RpcMethod rpcmethod_RecoverBackupKey_; const ::grpc::internal::RpcMethod rpcmethod_PullBackup_; + const ::grpc::internal::RpcMethod rpcmethod_AddAttachment_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -190,9 +217,10 @@ Service(); virtual ~Service(); 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 SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::backup::SendLogResponse* response); virtual ::grpc::Status RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream); virtual ::grpc::Status PullBackup(::grpc::ServerContext* context, const ::backup::PullBackupRequest* request, ::grpc::ServerWriter< ::backup::PullBackupResponse>* writer); + virtual ::grpc::Status AddAttachment(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* reader, ::google::protobuf::Empty* response); }; template class WithAsyncMethod_CreateNewBackup : public BaseClass { @@ -226,11 +254,11 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::backup::SendLogResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::SendLogRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::backup::SendLogResponse, ::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); } }; @@ -274,7 +302,27 @@ ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateNewBackup > > > AsyncService; + template + class WithAsyncMethod_AddAttachment : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_AddAttachment() { + ::grpc::Service::MarkMethodAsync(4); + } + ~WithAsyncMethod_AddAttachment() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddAttachment(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddAttachment(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::AddAttachmentRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(4, context, reader, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_CreateNewBackup > > > > AsyncService; template class WithCallbackMethod_CreateNewBackup : public BaseClass { private: @@ -305,20 +353,20 @@ public: WithCallbackMethod_SendLog() { ::grpc::Service::MarkMethodCallback(1, - new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>( + new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::backup::SendLogResponse>( [this]( - ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->SendLog(context, response); })); + ::grpc::CallbackServerContext* context, ::backup::SendLogResponse* response) { return this->SendLog(context, response); })); } ~WithCallbackMethod_SendLog() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::backup::SendLogResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerReadReactor< ::backup::SendLogRequest>* SendLog( - ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + ::grpc::CallbackServerContext* /*context*/, ::backup::SendLogResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_RecoverBackupKey : public BaseClass { @@ -365,7 +413,29 @@ virtual ::grpc::ServerWriteReactor< ::backup::PullBackupResponse>* PullBackup( ::grpc::CallbackServerContext* /*context*/, const ::backup::PullBackupRequest* /*request*/) { return nullptr; } }; - typedef WithCallbackMethod_CreateNewBackup > > > CallbackService; + template + class WithCallbackMethod_AddAttachment : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithCallbackMethod_AddAttachment() { + ::grpc::Service::MarkMethodCallback(4, + new ::grpc::internal::CallbackClientStreamingHandler< ::backup::AddAttachmentRequest, ::google::protobuf::Empty>( + [this]( + ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->AddAttachment(context, response); })); + } + ~WithCallbackMethod_AddAttachment() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddAttachment(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerReadReactor< ::backup::AddAttachmentRequest>* AddAttachment( + ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } + }; + typedef WithCallbackMethod_CreateNewBackup > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_CreateNewBackup : public BaseClass { @@ -396,7 +466,7 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::backup::SendLogResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -436,6 +506,23 @@ } }; template + class WithGenericMethod_AddAttachment : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_AddAttachment() { + ::grpc::Service::MarkMethodGeneric(4); + } + ~WithGenericMethod_AddAttachment() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddAttachment(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template class WithRawMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -467,7 +554,7 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::backup::SendLogResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -516,6 +603,26 @@ } }; template + class WithRawMethod_AddAttachment : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_AddAttachment() { + ::grpc::Service::MarkMethodRaw(4); + } + ~WithRawMethod_AddAttachment() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddAttachment(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestAddAttachment(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(4, context, reader, new_call_cq, notification_cq, tag); + } + }; + template class WithRawCallbackMethod_CreateNewBackup : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -553,7 +660,7 @@ BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::backup::SendLogResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -605,6 +712,28 @@ virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullBackup( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; + template + class WithRawCallbackMethod_AddAttachment : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawCallbackMethod_AddAttachment() { + ::grpc::Service::MarkMethodRawCallback(4, + new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this]( + ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->AddAttachment(context, response); })); + } + ~WithRawCallbackMethod_AddAttachment() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status AddAttachment(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* AddAttachment( + ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } + }; typedef Service StreamedUnaryService; template class WithSplitStreamingMethod_PullBackup : public BaseClass { 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 @@ -26,6 +26,7 @@ "/backup.BackupService/SendLog", "/backup.BackupService/RecoverBackupKey", "/backup.BackupService/PullBackup", + "/backup.BackupService/AddAttachment", }; std::unique_ptr< BackupService::Stub> BackupService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { @@ -39,6 +40,7 @@ , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) , rpcmethod_RecoverBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel) , rpcmethod_PullBackup_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_AddAttachment_(BackupService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) {} ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::CreateNewBackupRaw(::grpc::ClientContext* context) { @@ -57,19 +59,19 @@ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, false, nullptr); } -::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { +::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response) { return ::grpc::internal::ClientWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), rpcmethod_SendLog_, context, response); } -void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) { +void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) { ::grpc::internal::ClientCallbackWriterFactory< ::backup::SendLogRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, response, reactor); } -::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { +::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq, void* tag) { return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, true, tag); } -::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::backup::SendLogResponse* response, ::grpc::CompletionQueue* cq) { return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, false, nullptr); } @@ -105,6 +107,22 @@ return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, request, false, nullptr); } +::grpc::ClientWriter< ::backup::AddAttachmentRequest>* BackupService::Stub::AddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) { + return ::grpc::internal::ClientWriterFactory< ::backup::AddAttachmentRequest>::Create(channel_.get(), rpcmethod_AddAttachment_, context, response); +} + +void BackupService::Stub::async::AddAttachment(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::AddAttachmentRequest>* reactor) { + ::grpc::internal::ClientCallbackWriterFactory< ::backup::AddAttachmentRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_AddAttachment_, context, response, reactor); +} + +::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>* BackupService::Stub::AsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< ::backup::AddAttachmentRequest>::Create(channel_.get(), cq, rpcmethod_AddAttachment_, context, response, true, tag); +} + +::grpc::ClientAsyncWriter< ::backup::AddAttachmentRequest>* BackupService::Stub::PrepareAsyncAddAttachmentRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< ::backup::AddAttachmentRequest>::Create(channel_.get(), cq, rpcmethod_AddAttachment_, context, response, false, nullptr); +} + BackupService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[0], @@ -119,11 +137,11 @@ AddMethod(new ::grpc::internal::RpcServiceMethod( BackupService_method_names[1], ::grpc::internal::RpcMethod::CLIENT_STREAMING, - new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty>( + new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::backup::SendLogResponse>( [](BackupService::Service* service, ::grpc::ServerContext* ctx, ::grpc::ServerReader<::backup::SendLogRequest>* reader, - ::google::protobuf::Empty* resp) { + ::backup::SendLogResponse* resp) { return service->SendLog(ctx, reader, resp); }, this))); AddMethod(new ::grpc::internal::RpcServiceMethod( @@ -146,6 +164,16 @@ ::grpc::ServerWriter<::backup::PullBackupResponse>* writer) { return service->PullBackup(ctx, req, writer); }, this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + BackupService_method_names[4], + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::AddAttachmentRequest, ::google::protobuf::Empty>( + [](BackupService::Service* service, + ::grpc::ServerContext* ctx, + ::grpc::ServerReader<::backup::AddAttachmentRequest>* reader, + ::google::protobuf::Empty* resp) { + return service->AddAttachment(ctx, reader, resp); + }, this))); } BackupService::Service::~Service() { @@ -157,7 +185,7 @@ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response) { +::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::backup::SendLogResponse* response) { (void) context; (void) reader; (void) response; @@ -177,6 +205,13 @@ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } +::grpc::Status BackupService::Service::AddAttachment(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::AddAttachmentRequest>* reader, ::google::protobuf::Empty* response) { + (void) context; + (void) reader; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + } // namespace backup 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[7] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10] 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 AddAttachmentRequest; +struct AddAttachmentRequestDefaultTypeInternal; +extern AddAttachmentRequestDefaultTypeInternal _AddAttachmentRequest_default_instance_; +class AttachmentParameters; +struct AttachmentParametersDefaultTypeInternal; +extern AttachmentParametersDefaultTypeInternal _AttachmentParameters_default_instance_; class CreateNewBackupRequest; struct CreateNewBackupRequestDefaultTypeInternal; extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_; @@ -77,8 +83,13 @@ class SendLogRequest; struct SendLogRequestDefaultTypeInternal; extern SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_; +class SendLogResponse; +struct SendLogResponseDefaultTypeInternal; +extern SendLogResponseDefaultTypeInternal _SendLogResponse_default_instance_; } // namespace backup PROTOBUF_NAMESPACE_OPEN +template<> ::backup::AddAttachmentRequest* Arena::CreateMaybeMessage<::backup::AddAttachmentRequest>(Arena*); +template<> ::backup::AttachmentParameters* Arena::CreateMaybeMessage<::backup::AttachmentParameters>(Arena*); template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*); template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(Arena*); template<> ::backup::PullBackupRequest* Arena::CreateMaybeMessage<::backup::PullBackupRequest>(Arena*); @@ -86,6 +97,7 @@ template<> ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyRequest>(Arena*); template<> ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage<::backup::RecoverBackupKeyResponse>(Arena*); template<> ::backup::SendLogRequest* Arena::CreateMaybeMessage<::backup::SendLogRequest>(Arena*); +template<> ::backup::SendLogResponse* Arena::CreateMaybeMessage<::backup::SendLogResponse>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace backup { @@ -131,9 +143,10 @@ } enum DataCase { kUserID = 1, - kKeyEntropy = 2, - kNewCompactionHash = 3, - kNewCompactionChunk = 4, + kDeviceID = 2, + kKeyEntropy = 3, + kNewCompactionHash = 4, + kNewCompactionChunk = 5, DATA_NOT_SET = 0, }; @@ -213,9 +226,10 @@ enum : int { kUserIDFieldNumber = 1, - kKeyEntropyFieldNumber = 2, - kNewCompactionHashFieldNumber = 3, - kNewCompactionChunkFieldNumber = 4, + kDeviceIDFieldNumber = 2, + kKeyEntropyFieldNumber = 3, + kNewCompactionHashFieldNumber = 4, + kNewCompactionChunkFieldNumber = 5, }; // string userID = 1; bool has_userid() const; @@ -237,7 +251,27 @@ std::string* _internal_mutable_userid(); public: - // bytes keyEntropy = 2; + // string deviceID = 2; + bool has_deviceid() const; + private: + bool _internal_has_deviceid() const; + public: + void clear_deviceid(); + const std::string& deviceid() const; + void set_deviceid(const std::string& value); + void set_deviceid(std::string&& value); + void set_deviceid(const char* value); + void set_deviceid(const char* value, size_t size); + std::string* mutable_deviceid(); + std::string* release_deviceid(); + void set_allocated_deviceid(std::string* deviceid); + private: + const std::string& _internal_deviceid() const; + void _internal_set_deviceid(const std::string& value); + std::string* _internal_mutable_deviceid(); + public: + + // bytes keyEntropy = 3; bool has_keyentropy() const; private: bool _internal_has_keyentropy() const; @@ -257,7 +291,7 @@ std::string* _internal_mutable_keyentropy(); public: - // bytes newCompactionHash = 3; + // bytes newCompactionHash = 4; bool has_newcompactionhash() const; private: bool _internal_has_newcompactionhash() const; @@ -277,7 +311,7 @@ std::string* _internal_mutable_newcompactionhash(); public: - // bytes newCompactionChunk = 4; + // bytes newCompactionChunk = 5; bool has_newcompactionchunk() const; private: bool _internal_has_newcompactionchunk() const; @@ -303,6 +337,7 @@ private: class _Internal; void set_has_userid(); + void set_has_deviceid(); void set_has_keyentropy(); void set_has_newcompactionhash(); void set_has_newcompactionchunk(); @@ -317,6 +352,7 @@ constexpr DataUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr keyentropy_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionhash_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionchunk_; @@ -709,6 +745,150 @@ }; // ------------------------------------------------------------------- +class SendLogResponse PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogResponse) */ { + public: + inline SendLogResponse() : SendLogResponse(nullptr) {} + virtual ~SendLogResponse(); + explicit constexpr SendLogResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SendLogResponse(const SendLogResponse& from); + SendLogResponse(SendLogResponse&& from) noexcept + : SendLogResponse() { + *this = ::std::move(from); + } + + inline SendLogResponse& operator=(const SendLogResponse& from) { + CopyFrom(from); + return *this; + } + inline SendLogResponse& operator=(SendLogResponse&& 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 SendLogResponse& default_instance() { + return *internal_default_instance(); + } + static inline const SendLogResponse* internal_default_instance() { + return reinterpret_cast( + &_SendLogResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(SendLogResponse& a, SendLogResponse& b) { + a.Swap(&b); + } + inline void Swap(SendLogResponse* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SendLogResponse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SendLogResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + SendLogResponse* 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 SendLogResponse& from); + void MergeFrom(const SendLogResponse& 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(SendLogResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.SendLogResponse"; + } + protected: + explicit SendLogResponse(::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 { + kLogIDFieldNumber = 1, + }; + // string logID = 1; + void clear_logid(); + const std::string& logid() const; + void set_logid(const std::string& value); + void set_logid(std::string&& value); + void set_logid(const char* value); + void set_logid(const char* value, size_t size); + std::string* mutable_logid(); + std::string* release_logid(); + void set_allocated_logid(std::string* logid); + private: + const std::string& _internal_logid() const; + void _internal_set_logid(const std::string& value); + std::string* _internal_mutable_logid(); + public: + + // @@protoc_insertion_point(class_scope:backup.SendLogResponse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logid_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_backup_2eproto; +}; +// ------------------------------------------------------------------- + class RecoverBackupKeyRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyRequest) */ { public: @@ -752,7 +932,7 @@ &_RecoverBackupKeyRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 3; + 4; friend void swap(RecoverBackupKeyRequest& a, RecoverBackupKeyRequest& b) { a.Swap(&b); @@ -896,7 +1076,7 @@ &_RecoverBackupKeyResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 4; + 5; friend void swap(RecoverBackupKeyResponse& a, RecoverBackupKeyResponse& b) { a.Swap(&b); @@ -1040,7 +1220,7 @@ &_PullBackupRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 6; friend void swap(PullBackupRequest& a, PullBackupRequest& b) { a.Swap(&b); @@ -1208,7 +1388,7 @@ &_PullBackupResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 6; + 7; friend void swap(PullBackupResponse& a, PullBackupResponse& b) { a.Swap(&b); @@ -1346,6 +1526,373 @@ friend struct ::TableStruct_backup_2eproto; }; +// ------------------------------------------------------------------- + +class AttachmentParameters PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.AttachmentParameters) */ { + public: + inline AttachmentParameters() : AttachmentParameters(nullptr) {} + virtual ~AttachmentParameters(); + explicit constexpr AttachmentParameters(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AttachmentParameters(const AttachmentParameters& from); + AttachmentParameters(AttachmentParameters&& from) noexcept + : AttachmentParameters() { + *this = ::std::move(from); + } + + inline AttachmentParameters& operator=(const AttachmentParameters& from) { + CopyFrom(from); + return *this; + } + inline AttachmentParameters& operator=(AttachmentParameters&& 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 AttachmentParameters& default_instance() { + return *internal_default_instance(); + } + static inline const AttachmentParameters* internal_default_instance() { + return reinterpret_cast( + &_AttachmentParameters_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(AttachmentParameters& a, AttachmentParameters& b) { + a.Swap(&b); + } + inline void Swap(AttachmentParameters* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AttachmentParameters* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AttachmentParameters* New() const final { + return CreateMaybeMessage(nullptr); + } + + AttachmentParameters* 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 AttachmentParameters& from); + void MergeFrom(const AttachmentParameters& 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(AttachmentParameters* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.AttachmentParameters"; + } + protected: + explicit AttachmentParameters(::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 { + kUserIDFieldNumber = 1, + kBackupIDFieldNumber = 2, + kLogIDFieldNumber = 3, + }; + // string userID = 1; + void clear_userid(); + const std::string& userid() const; + void set_userid(const std::string& value); + void set_userid(std::string&& value); + void set_userid(const char* value); + void set_userid(const char* value, size_t size); + std::string* mutable_userid(); + std::string* release_userid(); + void set_allocated_userid(std::string* userid); + private: + const std::string& _internal_userid() const; + void _internal_set_userid(const std::string& value); + std::string* _internal_mutable_userid(); + public: + + // string backupID = 2; + 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 logID = 3; + void clear_logid(); + const std::string& logid() const; + void set_logid(const std::string& value); + void set_logid(std::string&& value); + void set_logid(const char* value); + void set_logid(const char* value, size_t size); + std::string* mutable_logid(); + std::string* release_logid(); + void set_allocated_logid(std::string* logid); + private: + const std::string& _internal_logid() const; + void _internal_set_logid(const std::string& value); + std::string* _internal_mutable_logid(); + public: + + // @@protoc_insertion_point(class_scope:backup.AttachmentParameters) + private: + class _Internal; + + 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 backupid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logid_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_backup_2eproto; +}; +// ------------------------------------------------------------------- + +class AddAttachmentRequest PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.AddAttachmentRequest) */ { + public: + inline AddAttachmentRequest() : AddAttachmentRequest(nullptr) {} + virtual ~AddAttachmentRequest(); + explicit constexpr AddAttachmentRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AddAttachmentRequest(const AddAttachmentRequest& from); + AddAttachmentRequest(AddAttachmentRequest&& from) noexcept + : AddAttachmentRequest() { + *this = ::std::move(from); + } + + inline AddAttachmentRequest& operator=(const AddAttachmentRequest& from) { + CopyFrom(from); + return *this; + } + inline AddAttachmentRequest& operator=(AddAttachmentRequest&& 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 AddAttachmentRequest& default_instance() { + return *internal_default_instance(); + } + enum DataCase { + kAttachmentParameters = 1, + kHolder = 2, + DATA_NOT_SET = 0, + }; + + static inline const AddAttachmentRequest* internal_default_instance() { + return reinterpret_cast( + &_AddAttachmentRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(AddAttachmentRequest& a, AddAttachmentRequest& b) { + a.Swap(&b); + } + inline void Swap(AddAttachmentRequest* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AddAttachmentRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AddAttachmentRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + AddAttachmentRequest* 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 AddAttachmentRequest& from); + void MergeFrom(const AddAttachmentRequest& 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(AddAttachmentRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "backup.AddAttachmentRequest"; + } + protected: + explicit AddAttachmentRequest(::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 { + kAttachmentParametersFieldNumber = 1, + kHolderFieldNumber = 2, + }; + // .backup.AttachmentParameters attachmentParameters = 1; + bool has_attachmentparameters() const; + private: + bool _internal_has_attachmentparameters() const; + public: + void clear_attachmentparameters(); + const ::backup::AttachmentParameters& attachmentparameters() const; + ::backup::AttachmentParameters* release_attachmentparameters(); + ::backup::AttachmentParameters* mutable_attachmentparameters(); + void set_allocated_attachmentparameters(::backup::AttachmentParameters* attachmentparameters); + private: + const ::backup::AttachmentParameters& _internal_attachmentparameters() const; + ::backup::AttachmentParameters* _internal_mutable_attachmentparameters(); + public: + void unsafe_arena_set_allocated_attachmentparameters( + ::backup::AttachmentParameters* attachmentparameters); + ::backup::AttachmentParameters* unsafe_arena_release_attachmentparameters(); + + // string holder = 2; + bool has_holder() const; + private: + bool _internal_has_holder() const; + public: + void clear_holder(); + const std::string& holder() const; + void set_holder(const std::string& value); + void set_holder(std::string&& value); + void set_holder(const char* value); + void set_holder(const char* value, size_t size); + std::string* mutable_holder(); + std::string* release_holder(); + void set_allocated_holder(std::string* holder); + private: + const std::string& _internal_holder() const; + void _internal_set_holder(const std::string& value); + std::string* _internal_mutable_holder(); + public: + + void clear_data(); + DataCase data_case() const; + // @@protoc_insertion_point(class_scope:backup.AddAttachmentRequest) + private: + class _Internal; + void set_has_attachmentparameters(); + void set_has_holder(); + + 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_; + ::backup::AttachmentParameters* attachmentparameters_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr holder_; + } data_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_backup_2eproto; +}; // =================================================================== @@ -1417,57 +1964,167 @@ set_has_userid(); data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + 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) +} + +// string deviceID = 2; +inline bool CreateNewBackupRequest::_internal_has_deviceid() const { + return data_case() == kDeviceID; +} +inline bool CreateNewBackupRequest::has_deviceid() const { + return _internal_has_deviceid(); +} +inline void CreateNewBackupRequest::set_has_deviceid() { + _oneof_case_[0] = kDeviceID; +} +inline void CreateNewBackupRequest::clear_deviceid() { + if (_internal_has_deviceid()) { + data_.deviceid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& CreateNewBackupRequest::deviceid() const { + // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.deviceID) + return _internal_deviceid(); +} +inline void CreateNewBackupRequest::set_deviceid(const std::string& value) { + _internal_set_deviceid(value); + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.deviceID) +} +inline std::string* CreateNewBackupRequest::mutable_deviceid() { + // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.deviceID) + return _internal_mutable_deviceid(); +} +inline const std::string& CreateNewBackupRequest::_internal_deviceid() const { + if (_internal_has_deviceid()) { + return data_.deviceid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void CreateNewBackupRequest::_internal_set_deviceid(const std::string& value) { + if (!_internal_has_deviceid()) { + clear_data(); + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void CreateNewBackupRequest::set_deviceid(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.deviceID) + if (!_internal_has_deviceid()) { + clear_data(); + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.deviceid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.deviceID) +} +inline void CreateNewBackupRequest::set_deviceid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_deviceid()) { + clear_data(); + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.userID) + // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.deviceID) } -inline void CreateNewBackupRequest::set_userid(const char* value, +inline void CreateNewBackupRequest::set_deviceid(const char* value, size_t size) { - if (!_internal_has_userid()) { + if (!_internal_has_deviceid()) { clear_data(); - set_has_userid(); - data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - data_.userid_.Set( + data_.deviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.userID) + // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.deviceID) } -inline std::string* CreateNewBackupRequest::_internal_mutable_userid() { - if (!_internal_has_userid()) { +inline std::string* CreateNewBackupRequest::_internal_mutable_deviceid() { + if (!_internal_has_deviceid()) { clear_data(); - set_has_userid(); - data_.userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return data_.userid_.Mutable( + return data_.deviceid_.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()) { +inline std::string* CreateNewBackupRequest::release_deviceid() { + // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.deviceID) + if (_internal_has_deviceid()) { clear_has_data(); - return data_.userid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return data_.deviceid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } -inline void CreateNewBackupRequest::set_allocated_userid(std::string* userid) { +inline void CreateNewBackupRequest::set_allocated_deviceid(std::string* deviceid) { if (has_data()) { clear_data(); } - if (userid != nullptr) { - set_has_userid(); - data_.userid_.UnsafeSetDefault(userid); + if (deviceid != nullptr) { + set_has_deviceid(); + data_.deviceid_.UnsafeSetDefault(deviceid); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(userid); + arena->Own(deviceid); } } - // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.userID) + // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.deviceID) } -// bytes keyEntropy = 2; +// bytes keyEntropy = 3; inline bool CreateNewBackupRequest::_internal_has_keyentropy() const { return data_case() == kKeyEntropy; } @@ -1577,7 +2234,7 @@ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.keyEntropy) } -// bytes newCompactionHash = 3; +// bytes newCompactionHash = 4; inline bool CreateNewBackupRequest::_internal_has_newcompactionhash() const { return data_case() == kNewCompactionHash; } @@ -1687,7 +2344,7 @@ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newCompactionHash) } -// bytes newCompactionChunk = 4; +// bytes newCompactionChunk = 5; inline bool CreateNewBackupRequest::_internal_has_newcompactionchunk() const { return data_case() == kNewCompactionChunk; } @@ -2326,6 +2983,71 @@ } // ------------------------------------------------------------------- +// SendLogResponse + +// string logID = 1; +inline void SendLogResponse::clear_logid() { + logid_.ClearToEmpty(); +} +inline const std::string& SendLogResponse::logid() const { + // @@protoc_insertion_point(field_get:backup.SendLogResponse.logID) + return _internal_logid(); +} +inline void SendLogResponse::set_logid(const std::string& value) { + _internal_set_logid(value); + // @@protoc_insertion_point(field_set:backup.SendLogResponse.logID) +} +inline std::string* SendLogResponse::mutable_logid() { + // @@protoc_insertion_point(field_mutable:backup.SendLogResponse.logID) + return _internal_mutable_logid(); +} +inline const std::string& SendLogResponse::_internal_logid() const { + return logid_.Get(); +} +inline void SendLogResponse::_internal_set_logid(const std::string& value) { + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void SendLogResponse::set_logid(std::string&& value) { + + logid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.SendLogResponse.logID) +} +inline void SendLogResponse::set_logid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.SendLogResponse.logID) +} +inline void SendLogResponse::set_logid(const char* value, + size_t size) { + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.SendLogResponse.logID) +} +inline std::string* SendLogResponse::_internal_mutable_logid() { + + return logid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SendLogResponse::release_logid() { + // @@protoc_insertion_point(field_release:backup.SendLogResponse.logID) + return logid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SendLogResponse::set_allocated_logid(std::string* logid) { + if (logid != nullptr) { + + } else { + + } + logid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.SendLogResponse.logID) +} + +// ------------------------------------------------------------------- + // RecoverBackupKeyRequest // string userID = 1; @@ -2813,6 +3535,389 @@ inline PullBackupResponse::DataCase PullBackupResponse::data_case() const { return PullBackupResponse::DataCase(_oneof_case_[0]); } +// ------------------------------------------------------------------- + +// AttachmentParameters + +// string userID = 1; +inline void AttachmentParameters::clear_userid() { + userid_.ClearToEmpty(); +} +inline const std::string& AttachmentParameters::userid() const { + // @@protoc_insertion_point(field_get:backup.AttachmentParameters.userID) + return _internal_userid(); +} +inline void AttachmentParameters::set_userid(const std::string& value) { + _internal_set_userid(value); + // @@protoc_insertion_point(field_set:backup.AttachmentParameters.userID) +} +inline std::string* AttachmentParameters::mutable_userid() { + // @@protoc_insertion_point(field_mutable:backup.AttachmentParameters.userID) + return _internal_mutable_userid(); +} +inline const std::string& AttachmentParameters::_internal_userid() const { + return userid_.Get(); +} +inline void AttachmentParameters::_internal_set_userid(const std::string& value) { + + userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void AttachmentParameters::set_userid(std::string&& value) { + + userid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.AttachmentParameters.userID) +} +inline void AttachmentParameters::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.AttachmentParameters.userID) +} +inline void AttachmentParameters::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.AttachmentParameters.userID) +} +inline std::string* AttachmentParameters::_internal_mutable_userid() { + + return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* AttachmentParameters::release_userid() { + // @@protoc_insertion_point(field_release:backup.AttachmentParameters.userID) + return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void AttachmentParameters::set_allocated_userid(std::string* userid) { + if (userid != nullptr) { + + } else { + + } + userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.AttachmentParameters.userID) +} + +// string backupID = 2; +inline void AttachmentParameters::clear_backupid() { + backupid_.ClearToEmpty(); +} +inline const std::string& AttachmentParameters::backupid() const { + // @@protoc_insertion_point(field_get:backup.AttachmentParameters.backupID) + return _internal_backupid(); +} +inline void AttachmentParameters::set_backupid(const std::string& value) { + _internal_set_backupid(value); + // @@protoc_insertion_point(field_set:backup.AttachmentParameters.backupID) +} +inline std::string* AttachmentParameters::mutable_backupid() { + // @@protoc_insertion_point(field_mutable:backup.AttachmentParameters.backupID) + return _internal_mutable_backupid(); +} +inline const std::string& AttachmentParameters::_internal_backupid() const { + return backupid_.Get(); +} +inline void AttachmentParameters::_internal_set_backupid(const std::string& value) { + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void AttachmentParameters::set_backupid(std::string&& value) { + + backupid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.AttachmentParameters.backupID) +} +inline void AttachmentParameters::set_backupid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.AttachmentParameters.backupID) +} +inline void AttachmentParameters::set_backupid(const char* value, + size_t size) { + + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.AttachmentParameters.backupID) +} +inline std::string* AttachmentParameters::_internal_mutable_backupid() { + + return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* AttachmentParameters::release_backupid() { + // @@protoc_insertion_point(field_release:backup.AttachmentParameters.backupID) + return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void AttachmentParameters::set_allocated_backupid(std::string* backupid) { + if (backupid != nullptr) { + + } else { + + } + backupid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), backupid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.AttachmentParameters.backupID) +} + +// string logID = 3; +inline void AttachmentParameters::clear_logid() { + logid_.ClearToEmpty(); +} +inline const std::string& AttachmentParameters::logid() const { + // @@protoc_insertion_point(field_get:backup.AttachmentParameters.logID) + return _internal_logid(); +} +inline void AttachmentParameters::set_logid(const std::string& value) { + _internal_set_logid(value); + // @@protoc_insertion_point(field_set:backup.AttachmentParameters.logID) +} +inline std::string* AttachmentParameters::mutable_logid() { + // @@protoc_insertion_point(field_mutable:backup.AttachmentParameters.logID) + return _internal_mutable_logid(); +} +inline const std::string& AttachmentParameters::_internal_logid() const { + return logid_.Get(); +} +inline void AttachmentParameters::_internal_set_logid(const std::string& value) { + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void AttachmentParameters::set_logid(std::string&& value) { + + logid_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.AttachmentParameters.logID) +} +inline void AttachmentParameters::set_logid(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.AttachmentParameters.logID) +} +inline void AttachmentParameters::set_logid(const char* value, + size_t size) { + + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.AttachmentParameters.logID) +} +inline std::string* AttachmentParameters::_internal_mutable_logid() { + + return logid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* AttachmentParameters::release_logid() { + // @@protoc_insertion_point(field_release:backup.AttachmentParameters.logID) + return logid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void AttachmentParameters::set_allocated_logid(std::string* logid) { + if (logid != nullptr) { + + } else { + + } + logid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logid, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:backup.AttachmentParameters.logID) +} + +// ------------------------------------------------------------------- + +// AddAttachmentRequest + +// .backup.AttachmentParameters attachmentParameters = 1; +inline bool AddAttachmentRequest::_internal_has_attachmentparameters() const { + return data_case() == kAttachmentParameters; +} +inline bool AddAttachmentRequest::has_attachmentparameters() const { + return _internal_has_attachmentparameters(); +} +inline void AddAttachmentRequest::set_has_attachmentparameters() { + _oneof_case_[0] = kAttachmentParameters; +} +inline void AddAttachmentRequest::clear_attachmentparameters() { + if (_internal_has_attachmentparameters()) { + if (GetArena() == nullptr) { + delete data_.attachmentparameters_; + } + clear_has_data(); + } +} +inline ::backup::AttachmentParameters* AddAttachmentRequest::release_attachmentparameters() { + // @@protoc_insertion_point(field_release:backup.AddAttachmentRequest.attachmentParameters) + if (_internal_has_attachmentparameters()) { + clear_has_data(); + ::backup::AttachmentParameters* temp = data_.attachmentparameters_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + data_.attachmentparameters_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::backup::AttachmentParameters& AddAttachmentRequest::_internal_attachmentparameters() const { + return _internal_has_attachmentparameters() + ? *data_.attachmentparameters_ + : reinterpret_cast< ::backup::AttachmentParameters&>(::backup::_AttachmentParameters_default_instance_); +} +inline const ::backup::AttachmentParameters& AddAttachmentRequest::attachmentparameters() const { + // @@protoc_insertion_point(field_get:backup.AddAttachmentRequest.attachmentParameters) + return _internal_attachmentparameters(); +} +inline ::backup::AttachmentParameters* AddAttachmentRequest::unsafe_arena_release_attachmentparameters() { + // @@protoc_insertion_point(field_unsafe_arena_release:backup.AddAttachmentRequest.attachmentParameters) + if (_internal_has_attachmentparameters()) { + clear_has_data(); + ::backup::AttachmentParameters* temp = data_.attachmentparameters_; + data_.attachmentparameters_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void AddAttachmentRequest::unsafe_arena_set_allocated_attachmentparameters(::backup::AttachmentParameters* attachmentparameters) { + clear_data(); + if (attachmentparameters) { + set_has_attachmentparameters(); + data_.attachmentparameters_ = attachmentparameters; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.AddAttachmentRequest.attachmentParameters) +} +inline ::backup::AttachmentParameters* AddAttachmentRequest::_internal_mutable_attachmentparameters() { + if (!_internal_has_attachmentparameters()) { + clear_data(); + set_has_attachmentparameters(); + data_.attachmentparameters_ = CreateMaybeMessage< ::backup::AttachmentParameters >(GetArena()); + } + return data_.attachmentparameters_; +} +inline ::backup::AttachmentParameters* AddAttachmentRequest::mutable_attachmentparameters() { + // @@protoc_insertion_point(field_mutable:backup.AddAttachmentRequest.attachmentParameters) + return _internal_mutable_attachmentparameters(); +} + +// string holder = 2; +inline bool AddAttachmentRequest::_internal_has_holder() const { + return data_case() == kHolder; +} +inline bool AddAttachmentRequest::has_holder() const { + return _internal_has_holder(); +} +inline void AddAttachmentRequest::set_has_holder() { + _oneof_case_[0] = kHolder; +} +inline void AddAttachmentRequest::clear_holder() { + if (_internal_has_holder()) { + data_.holder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_data(); + } +} +inline const std::string& AddAttachmentRequest::holder() const { + // @@protoc_insertion_point(field_get:backup.AddAttachmentRequest.holder) + return _internal_holder(); +} +inline void AddAttachmentRequest::set_holder(const std::string& value) { + _internal_set_holder(value); + // @@protoc_insertion_point(field_set:backup.AddAttachmentRequest.holder) +} +inline std::string* AddAttachmentRequest::mutable_holder() { + // @@protoc_insertion_point(field_mutable:backup.AddAttachmentRequest.holder) + return _internal_mutable_holder(); +} +inline const std::string& AddAttachmentRequest::_internal_holder() const { + if (_internal_has_holder()) { + return data_.holder_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void AddAttachmentRequest::_internal_set_holder(const std::string& value) { + if (!_internal_has_holder()) { + clear_data(); + set_has_holder(); + data_.holder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.holder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline void AddAttachmentRequest::set_holder(std::string&& value) { + // @@protoc_insertion_point(field_set:backup.AddAttachmentRequest.holder) + if (!_internal_has_holder()) { + clear_data(); + set_has_holder(); + data_.holder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.holder_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); + // @@protoc_insertion_point(field_set_rvalue:backup.AddAttachmentRequest.holder) +} +inline void AddAttachmentRequest::set_holder(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!_internal_has_holder()) { + clear_data(); + set_has_holder(); + data_.holder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.holder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, + ::std::string(value), GetArena()); + // @@protoc_insertion_point(field_set_char:backup.AddAttachmentRequest.holder) +} +inline void AddAttachmentRequest::set_holder(const char* value, + size_t size) { + if (!_internal_has_holder()) { + clear_data(); + set_has_holder(); + data_.holder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + data_.holder_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( + reinterpret_cast(value), size), + GetArena()); + // @@protoc_insertion_point(field_set_pointer:backup.AddAttachmentRequest.holder) +} +inline std::string* AddAttachmentRequest::_internal_mutable_holder() { + if (!_internal_has_holder()) { + clear_data(); + set_has_holder(); + data_.holder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return data_.holder_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* AddAttachmentRequest::release_holder() { + // @@protoc_insertion_point(field_release:backup.AddAttachmentRequest.holder) + if (_internal_has_holder()) { + clear_has_data(); + return data_.holder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void AddAttachmentRequest::set_allocated_holder(std::string* holder) { + if (has_data()) { + clear_data(); + } + if (holder != nullptr) { + set_has_holder(); + data_.holder_.UnsafeSetDefault(holder); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(holder); + } + } + // @@protoc_insertion_point(field_set_allocated:backup.AddAttachmentRequest.holder) +} + +inline bool AddAttachmentRequest::has_data() const { + return data_case() != DATA_NOT_SET; +} +inline void AddAttachmentRequest::clear_has_data() { + _oneof_case_[0] = DATA_NOT_SET; +} +inline AddAttachmentRequest::DataCase AddAttachmentRequest::data_case() const { + return AddAttachmentRequest::DataCase(_oneof_case_[0]); +} #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -2828,6 +3933,12 @@ // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc --- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc +++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc @@ -53,6 +53,18 @@ }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_; +constexpr SendLogResponse::SendLogResponse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : logid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct SendLogResponseDefaultTypeInternal { + constexpr SendLogResponseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SendLogResponseDefaultTypeInternal() {} + union { + SendLogResponse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogResponseDefaultTypeInternal _SendLogResponse_default_instance_; constexpr RecoverBackupKeyRequest::RecoverBackupKeyRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} @@ -102,8 +114,34 @@ }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_; +constexpr AttachmentParameters::AttachmentParameters( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , backupid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , logid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct AttachmentParametersDefaultTypeInternal { + constexpr AttachmentParametersDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AttachmentParametersDefaultTypeInternal() {} + union { + AttachmentParameters _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AttachmentParametersDefaultTypeInternal _AttachmentParameters_default_instance_; +constexpr AddAttachmentRequest::AddAttachmentRequest( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct AddAttachmentRequestDefaultTypeInternal { + constexpr AddAttachmentRequestDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AddAttachmentRequestDefaultTypeInternal() {} + union { + AddAttachmentRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AddAttachmentRequestDefaultTypeInternal _AddAttachmentRequest_default_instance_; } // namespace backup -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[7]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[10]; 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; @@ -117,6 +155,7 @@ ::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_), @@ -135,6 +174,12 @@ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::SendLogResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::backup::SendLogResponse, logid_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -161,59 +206,89 @@ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::AttachmentParameters, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::backup::AttachmentParameters, userid_), + PROTOBUF_FIELD_OFFSET(::backup::AttachmentParameters, backupid_), + PROTOBUF_FIELD_OFFSET(::backup::AttachmentParameters, logid_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentRequest, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentRequest, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentRequest, data_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::backup::CreateNewBackupRequest)}, - { 10, -1, sizeof(::backup::CreateNewBackupResponse)}, - { 16, -1, sizeof(::backup::SendLogRequest)}, - { 26, -1, sizeof(::backup::RecoverBackupKeyRequest)}, - { 32, -1, sizeof(::backup::RecoverBackupKeyResponse)}, - { 38, -1, sizeof(::backup::PullBackupRequest)}, - { 45, -1, sizeof(::backup::PullBackupResponse)}, + { 11, -1, sizeof(::backup::CreateNewBackupResponse)}, + { 17, -1, sizeof(::backup::SendLogRequest)}, + { 27, -1, sizeof(::backup::SendLogResponse)}, + { 33, -1, sizeof(::backup::RecoverBackupKeyRequest)}, + { 39, -1, sizeof(::backup::RecoverBackupKeyResponse)}, + { 45, -1, sizeof(::backup::PullBackupRequest)}, + { 52, -1, sizeof(::backup::PullBackupResponse)}, + { 60, -1, sizeof(::backup::AttachmentParameters)}, + { 68, -1, sizeof(::backup::AddAttachmentRequest)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::backup::_CreateNewBackupRequest_default_instance_), reinterpret_cast(&::backup::_CreateNewBackupResponse_default_instance_), reinterpret_cast(&::backup::_SendLogRequest_default_instance_), + reinterpret_cast(&::backup::_SendLogResponse_default_instance_), reinterpret_cast(&::backup::_RecoverBackupKeyRequest_default_instance_), reinterpret_cast(&::backup::_RecoverBackupKeyResponse_default_instance_), reinterpret_cast(&::backup::_PullBackupRequest_default_instance_), reinterpret_cast(&::backup::_PullBackupResponse_default_instance_), + reinterpret_cast(&::backup::_AttachmentParameters_default_instance_), + reinterpret_cast(&::backup::_AddAttachmentRequest_default_instance_), }; const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\014backup.proto\022\006backup\032\033google/protobuf/" - "empty.proto\"\203\001\n\026CreateNewBackupRequest\022\020" - "\n\006userID\030\001 \001(\tH\000\022\024\n\nkeyEntropy\030\002 \001(\014H\000\022\033" - "\n\021newCompactionHash\030\003 \001(\014H\000\022\034\n\022newCompac" - "tionChunk\030\004 \001(\014H\000B\006\n\004data\"+\n\027CreateNewBa" - "ckupResponse\022\020\n\010backupID\030\001 \001(\t\"d\n\016SendLo" - "gRequest\022\020\n\006userID\030\001 \001(\tH\000\022\022\n\010backupID\030\002" - " \001(\tH\000\022\021\n\007logHash\030\003 \001(\014H\000\022\021\n\007logData\030\004 \001" - "(\014H\000B\006\n\004data\")\n\027RecoverBackupKeyRequest\022" - "\016\n\006userID\030\001 \001(\t\",\n\030RecoverBackupKeyRespo" - "nse\022\020\n\010backupID\030\004 \001(\t\"5\n\021PullBackupReque" - "st\022\016\n\006userID\030\001 \001(\t\022\020\n\010backupID\030\002 \001(\t\"K\n\022" - "PullBackupResponse\022\031\n\017compactionChunk\030\001 " - "\001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004data2\316\002\n\rBa" - "ckupService\022X\n\017CreateNewBackup\022\036.backup." - "CreateNewBackupRequest\032\037.backup.CreateNe" - "wBackupResponse\"\000(\0010\001\022=\n\007SendLog\022\026.backu" - "p.SendLogRequest\032\026.google.protobuf.Empty" + "empty.proto\"\227\001\n\026CreateNewBackupRequest\022\020" + "\n\006userID\030\001 \001(\tH\000\022\022\n\010deviceID\030\002 \001(\tH\000\022\024\n\n" + "keyEntropy\030\003 \001(\014H\000\022\033\n\021newCompactionHash\030" + "\004 \001(\014H\000\022\034\n\022newCompactionChunk\030\005 \001(\014H\000B\006\n" + "\004data\"+\n\027CreateNewBackupResponse\022\020\n\010back" + "upID\030\001 \001(\t\"d\n\016SendLogRequest\022\020\n\006userID\030\001" + " \001(\tH\000\022\022\n\010backupID\030\002 \001(\tH\000\022\021\n\007logHash\030\003 " + "\001(\014H\000\022\021\n\007logData\030\004 \001(\014H\000B\006\n\004data\" \n\017Send" + "LogResponse\022\r\n\005logID\030\001 \001(\t\")\n\027RecoverBac" + "kupKeyRequest\022\016\n\006userID\030\001 \001(\t\",\n\030Recover" + "BackupKeyResponse\022\020\n\010backupID\030\004 \001(\t\"5\n\021P" + "ullBackupRequest\022\016\n\006userID\030\001 \001(\t\022\020\n\010back" + "upID\030\002 \001(\t\"K\n\022PullBackupResponse\022\031\n\017comp" + "actionChunk\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B" + "\006\n\004data\"G\n\024AttachmentParameters\022\016\n\006userI" + "D\030\001 \001(\t\022\020\n\010backupID\030\002 \001(\t\022\r\n\005logID\030\003 \001(\t" + "\"n\n\024AddAttachmentRequest\022<\n\024attachmentPa" + "rameters\030\001 \001(\0132\034.backup.AttachmentParame" + "tersH\000\022\020\n\006holder\030\002 \001(\tH\000B\006\n\004data2\232\003\n\rBac" + "kupService\022X\n\017CreateNewBackup\022\036.backup.C" + "reateNewBackupRequest\032\037.backup.CreateNew" + "BackupResponse\"\000(\0010\001\022>\n\007SendLog\022\026.backup" + ".SendLogRequest\032\027.backup.SendLogResponse" "\"\000(\001\022[\n\020RecoverBackupKey\022\037.backup.Recove" "rBackupKeyRequest\032 .backup.RecoverBackup" "KeyResponse\"\000(\0010\001\022G\n\nPullBackup\022\031.backup" ".PullBackupRequest\032\032.backup.PullBackupRe" - "sponse\"\0000\001b\006proto3" + "sponse\"\0000\001\022I\n\rAddAttachment\022\034.backup.Add" + "AttachmentRequest\032\026.google.protobuf.Empt" + "y\"\000(\001b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = { - false, false, 898, descriptor_table_protodef_backup_2eproto, "backup.proto", - &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 7, + false, false, 1213, descriptor_table_protodef_backup_2eproto, "backup.proto", + &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 10, 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, }; @@ -248,6 +323,10 @@ _internal_set_userid(from._internal_userid()); break; } + case kDeviceID: { + _internal_set_deviceid(from._internal_deviceid()); + break; + } case kKeyEntropy: { _internal_set_keyentropy(from._internal_keyentropy()); break; @@ -301,6 +380,10 @@ data_.userid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } + case kDeviceID: { + data_.deviceid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } case kKeyEntropy: { data_.keyentropy_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; @@ -347,25 +430,34 @@ CHK_(ptr); } else goto handle_unusual; continue; - // bytes keyEntropy = 2; + // string deviceID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_keyentropy(); + auto str = _internal_mutable_deviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupRequest.deviceID")); CHK_(ptr); } else goto handle_unusual; continue; - // bytes newCompactionHash = 3; + // bytes keyEntropy = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_newcompactionhash(); + auto str = _internal_mutable_keyentropy(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; - // bytes newCompactionChunk = 4; + // bytes newCompactionHash = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_newcompactionhash(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes newCompactionChunk = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { auto str = _internal_mutable_newcompactionchunk(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); @@ -409,22 +501,32 @@ 1, this->_internal_userid(), target); } - // bytes keyEntropy = 2; + // string deviceID = 2; + if (_internal_has_deviceid()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_deviceid().data(), static_cast(this->_internal_deviceid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.CreateNewBackupRequest.deviceID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_deviceid(), target); + } + + // bytes keyEntropy = 3; if (_internal_has_keyentropy()) { target = stream->WriteBytesMaybeAliased( - 2, this->_internal_keyentropy(), target); + 3, this->_internal_keyentropy(), target); } - // bytes newCompactionHash = 3; + // bytes newCompactionHash = 4; if (_internal_has_newcompactionhash()) { target = stream->WriteBytesMaybeAliased( - 3, this->_internal_newcompactionhash(), target); + 4, this->_internal_newcompactionhash(), target); } - // bytes newCompactionChunk = 4; + // bytes newCompactionChunk = 5; if (_internal_has_newcompactionchunk()) { target = stream->WriteBytesMaybeAliased( - 4, this->_internal_newcompactionchunk(), target); + 5, this->_internal_newcompactionchunk(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -451,21 +553,28 @@ this->_internal_userid()); break; } - // bytes keyEntropy = 2; + // string deviceID = 2; + case kDeviceID: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_deviceid()); + break; + } + // bytes keyEntropy = 3; case kKeyEntropy: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_keyentropy()); break; } - // bytes newCompactionHash = 3; + // bytes newCompactionHash = 4; case kNewCompactionHash: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_newcompactionhash()); break; } - // bytes newCompactionChunk = 4; + // bytes newCompactionChunk = 5; case kNewCompactionChunk: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( @@ -512,6 +621,10 @@ _internal_set_userid(from._internal_userid()); break; } + case kDeviceID: { + _internal_set_deviceid(from._internal_deviceid()); + break; + } case kKeyEntropy: { _internal_set_keyentropy(from._internal_keyentropy()); break; @@ -1098,6 +1211,206 @@ } +// =================================================================== + +class SendLogResponse::_Internal { + public: +}; + +SendLogResponse::SendLogResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.SendLogResponse) +} +SendLogResponse::SendLogResponse(const SendLogResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_logid().empty()) { + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logid(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:backup.SendLogResponse) +} + +void SendLogResponse::SharedCtor() { +logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +SendLogResponse::~SendLogResponse() { + // @@protoc_insertion_point(destructor:backup.SendLogResponse) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SendLogResponse::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + logid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SendLogResponse::ArenaDtor(void* object) { + SendLogResponse* _this = reinterpret_cast< SendLogResponse* >(object); + (void)_this; +} +void SendLogResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SendLogResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SendLogResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.SendLogResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + logid_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SendLogResponse::_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 logID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_logid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogResponse.logID")); + 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* SendLogResponse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.SendLogResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string logID = 1; + if (this->logid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_logid().data(), static_cast(this->_internal_logid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.SendLogResponse.logID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_logid(), 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.SendLogResponse) + return target; +} + +size_t SendLogResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.SendLogResponse) + 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 logID = 1; + if (this->logid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_logid()); + } + + 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 SendLogResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.SendLogResponse) + GOOGLE_DCHECK_NE(&from, this); + const SendLogResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.SendLogResponse) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.SendLogResponse) + MergeFrom(*source); + } +} + +void SendLogResponse::MergeFrom(const SendLogResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.SendLogResponse) + 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.logid().size() > 0) { + _internal_set_logid(from._internal_logid()); + } +} + +void SendLogResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.SendLogResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SendLogResponse::CopyFrom(const SendLogResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.SendLogResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SendLogResponse::IsInitialized() const { + return true; +} + +void SendLogResponse::InternalSwap(SendLogResponse* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + logid_.Swap(&other->logid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SendLogResponse::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== class RecoverBackupKeyRequest::_Internal { @@ -1998,29 +2311,604 @@ } -// @@protoc_insertion_point(namespace_scope) -} // namespace backup -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage< ::backup::CreateNewBackupRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::CreateNewBackupRequest >(arena); +// =================================================================== + +class AttachmentParameters::_Internal { + public: +}; + +AttachmentParameters::AttachmentParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.AttachmentParameters) } -template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage< ::backup::CreateNewBackupResponse >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::CreateNewBackupResponse >(arena); +AttachmentParameters::AttachmentParameters(const AttachmentParameters& 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()); + } + backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_backupid().empty()) { + backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_backupid(), + GetArena()); + } + logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_logid().empty()) { + logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logid(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:backup.AttachmentParameters) } -template<> PROTOBUF_NOINLINE ::backup::SendLogRequest* Arena::CreateMaybeMessage< ::backup::SendLogRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::SendLogRequest >(arena); + +void AttachmentParameters::SharedCtor() { +userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyRequest >(arena); + +AttachmentParameters::~AttachmentParameters() { + // @@protoc_insertion_point(destructor:backup.AttachmentParameters) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyResponse >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyResponse >(arena); + +void AttachmentParameters::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + backupid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + logid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -template<> PROTOBUF_NOINLINE ::backup::PullBackupRequest* Arena::CreateMaybeMessage< ::backup::PullBackupRequest >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::PullBackupRequest >(arena); + +void AttachmentParameters::ArenaDtor(void* object) { + AttachmentParameters* _this = reinterpret_cast< AttachmentParameters* >(object); + (void)_this; } -template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) { - return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena); +void AttachmentParameters::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AttachmentParameters::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AttachmentParameters::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.AttachmentParameters) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + userid_.ClearToEmpty(); + backupid_.ClearToEmpty(); + logid_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AttachmentParameters::_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; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_userid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.AttachmentParameters.userID")); + 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.AttachmentParameters.backupID")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string logID = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_logid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.AttachmentParameters.logID")); + 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* AttachmentParameters::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.AttachmentParameters) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string userID = 1; + if (this->userid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_userid().data(), static_cast(this->_internal_userid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.AttachmentParameters.userID"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_userid(), target); + } + + // string backupID = 2; + if (this->backupid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_backupid().data(), static_cast(this->_internal_backupid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.AttachmentParameters.backupID"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_backupid(), target); + } + + // string logID = 3; + if (this->logid().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_logid().data(), static_cast(this->_internal_logid().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.AttachmentParameters.logID"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_logid(), 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.AttachmentParameters) + return target; +} + +size_t AttachmentParameters::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.AttachmentParameters) + 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()); + } + + // string backupID = 2; + if (this->backupid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_backupid()); + } + + // string logID = 3; + if (this->logid().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_logid()); + } + + 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 AttachmentParameters::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.AttachmentParameters) + GOOGLE_DCHECK_NE(&from, this); + const AttachmentParameters* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.AttachmentParameters) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.AttachmentParameters) + MergeFrom(*source); + } +} + +void AttachmentParameters::MergeFrom(const AttachmentParameters& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.AttachmentParameters) + 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()); + } + if (from.backupid().size() > 0) { + _internal_set_backupid(from._internal_backupid()); + } + if (from.logid().size() > 0) { + _internal_set_logid(from._internal_logid()); + } +} + +void AttachmentParameters::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.AttachmentParameters) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttachmentParameters::CopyFrom(const AttachmentParameters& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.AttachmentParameters) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttachmentParameters::IsInitialized() const { + return true; +} + +void AttachmentParameters::InternalSwap(AttachmentParameters* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + backupid_.Swap(&other->backupid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + logid_.Swap(&other->logid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AttachmentParameters::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +class AddAttachmentRequest::_Internal { + public: + static const ::backup::AttachmentParameters& attachmentparameters(const AddAttachmentRequest* msg); +}; + +const ::backup::AttachmentParameters& +AddAttachmentRequest::_Internal::attachmentparameters(const AddAttachmentRequest* msg) { + return *msg->data_.attachmentparameters_; +} +void AddAttachmentRequest::set_allocated_attachmentparameters(::backup::AttachmentParameters* attachmentparameters) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_data(); + if (attachmentparameters) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(attachmentparameters); + if (message_arena != submessage_arena) { + attachmentparameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, attachmentparameters, submessage_arena); + } + set_has_attachmentparameters(); + data_.attachmentparameters_ = attachmentparameters; + } + // @@protoc_insertion_point(field_set_allocated:backup.AddAttachmentRequest.attachmentParameters) +} +AddAttachmentRequest::AddAttachmentRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:backup.AddAttachmentRequest) +} +AddAttachmentRequest::AddAttachmentRequest(const AddAttachmentRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_data(); + switch (from.data_case()) { + case kAttachmentParameters: { + _internal_mutable_attachmentparameters()->::backup::AttachmentParameters::MergeFrom(from._internal_attachmentparameters()); + break; + } + case kHolder: { + _internal_set_holder(from._internal_holder()); + break; + } + case DATA_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:backup.AddAttachmentRequest) +} + +void AddAttachmentRequest::SharedCtor() { +clear_has_data(); +} + +AddAttachmentRequest::~AddAttachmentRequest() { + // @@protoc_insertion_point(destructor:backup.AddAttachmentRequest) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void AddAttachmentRequest::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_data()) { + clear_data(); + } +} + +void AddAttachmentRequest::ArenaDtor(void* object) { + AddAttachmentRequest* _this = reinterpret_cast< AddAttachmentRequest* >(object); + (void)_this; +} +void AddAttachmentRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AddAttachmentRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AddAttachmentRequest::clear_data() { +// @@protoc_insertion_point(one_of_clear_start:backup.AddAttachmentRequest) + switch (data_case()) { + case kAttachmentParameters: { + if (GetArena() == nullptr) { + delete data_.attachmentparameters_; + } + break; + } + case kHolder: { + data_.holder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case DATA_NOT_SET: { + break; + } + } + _oneof_case_[0] = DATA_NOT_SET; +} + + +void AddAttachmentRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:backup.AddAttachmentRequest) + ::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* AddAttachmentRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // .backup.AttachmentParameters attachmentParameters = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_attachmentparameters(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string holder = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_holder(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.AddAttachmentRequest.holder")); + 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* AddAttachmentRequest::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:backup.AddAttachmentRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .backup.AttachmentParameters attachmentParameters = 1; + if (_internal_has_attachmentparameters()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::attachmentparameters(this), target, stream); + } + + // string holder = 2; + if (_internal_has_holder()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_holder().data(), static_cast(this->_internal_holder().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "backup.AddAttachmentRequest.holder"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_holder(), 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.AddAttachmentRequest) + return target; +} + +size_t AddAttachmentRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:backup.AddAttachmentRequest) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (data_case()) { + // .backup.AttachmentParameters attachmentParameters = 1; + case kAttachmentParameters: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *data_.attachmentparameters_); + break; + } + // string holder = 2; + case kHolder: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_holder()); + 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 AddAttachmentRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:backup.AddAttachmentRequest) + GOOGLE_DCHECK_NE(&from, this); + const AddAttachmentRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.AddAttachmentRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.AddAttachmentRequest) + MergeFrom(*source); + } +} + +void AddAttachmentRequest::MergeFrom(const AddAttachmentRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:backup.AddAttachmentRequest) + 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 kAttachmentParameters: { + _internal_mutable_attachmentparameters()->::backup::AttachmentParameters::MergeFrom(from._internal_attachmentparameters()); + break; + } + case kHolder: { + _internal_set_holder(from._internal_holder()); + break; + } + case DATA_NOT_SET: { + break; + } + } +} + +void AddAttachmentRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:backup.AddAttachmentRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AddAttachmentRequest::CopyFrom(const AddAttachmentRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:backup.AddAttachmentRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AddAttachmentRequest::IsInitialized() const { + return true; +} + +void AddAttachmentRequest::InternalSwap(AddAttachmentRequest* 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 AddAttachmentRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace backup +PROTOBUF_NAMESPACE_OPEN +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); +} +template<> PROTOBUF_NOINLINE ::backup::SendLogResponse* Arena::CreateMaybeMessage< ::backup::SendLogResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::SendLogResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::PullBackupRequest* Arena::CreateMaybeMessage< ::backup::PullBackupRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::PullBackupRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::AttachmentParameters* Arena::CreateMaybeMessage< ::backup::AttachmentParameters >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::AttachmentParameters >(arena); +} +template<> PROTOBUF_NOINLINE ::backup::AddAttachmentRequest* Arena::CreateMaybeMessage< ::backup::AddAttachmentRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::backup::AddAttachmentRequest >(arena); } PROTOBUF_NAMESPACE_CLOSE 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 @@ -23,6 +23,7 @@ rpc SendLog(stream SendLogRequest) returns (SendLogResponse) {} rpc RecoverBackupKey(stream RecoverBackupKeyRequest) returns (stream RecoverBackupKeyResponse) {} rpc PullBackup(PullBackupRequest) returns (stream PullBackupResponse) {} + rpc AddAttachment(stream AddAttachmentRequest) returns (google.protobuf.Empty) {} } // CreateNewBackup @@ -79,3 +80,18 @@ bytes logChunk = 2; } } + +// AddAttachment + +message AttachmentParameters { + string userID = 1; + string backupID = 2; + string logID = 3; +} + +message AddAttachmentRequest { + oneof data { + AttachmentParameters attachmentParameters = 1; + string holder = 2; + } +}