Page Menu
Home
Phabricator
Search
Configure Global Search
Log In
Files
F3541315
D4080.id13140.diff
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Flag For Later
Size
118 KB
Referenced Files
None
Subscribers
None
D4080.id13140.diff
View Options
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,22 @@
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));
}
+ virtual ::grpc::Status AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::google::protobuf::Empty* response) = 0;
+ std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncAddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncAddAttachmentsRaw(context, request, cq));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncAddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncAddAttachmentsRaw(context, request, 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 AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
+ virtual void AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
};
typedef class async_interface experimental_async_interface;
virtual class async_interface* async() { return nullptr; }
@@ -99,15 +108,17 @@
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::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) = 0;
+ virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) = 0;
};
class Stub final : public StubInterface {
public:
@@ -121,13 +132,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 +159,22 @@
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));
}
+ ::grpc::Status AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::google::protobuf::Empty* response) override;
+ std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncAddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncAddAttachmentsRaw(context, request, cq));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncAddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncAddAttachmentsRaw(context, request, 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 AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
+ void AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
private:
friend class Stub;
explicit async(Stub* stub): stub_(stub) { }
@@ -169,19 +189,22 @@
::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::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) override;
+ ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::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_AddAttachments_;
};
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
@@ -190,9 +213,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 AddAttachments(::grpc::ServerContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response);
};
template <class BaseClass>
class WithAsyncMethod_CreateNewBackup : public BaseClass {
@@ -226,11 +250,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 +298,27 @@
::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
}
};
- typedef WithAsyncMethod_CreateNewBackup<WithAsyncMethod_SendLog<WithAsyncMethod_RecoverBackupKey<WithAsyncMethod_PullBackup<Service > > > > AsyncService;
+ template <class BaseClass>
+ class WithAsyncMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithAsyncMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodAsync(4);
+ }
+ ~WithAsyncMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ void RequestAddAttachments(::grpc::ServerContext* context, ::backup::AddAttachmentsRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
+ }
+ };
+ typedef WithAsyncMethod_CreateNewBackup<WithAsyncMethod_SendLog<WithAsyncMethod_RecoverBackupKey<WithAsyncMethod_PullBackup<WithAsyncMethod_AddAttachments<Service > > > > > AsyncService;
template <class BaseClass>
class WithCallbackMethod_CreateNewBackup : public BaseClass {
private:
@@ -305,20 +349,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 BaseClass>
class WithCallbackMethod_RecoverBackupKey : public BaseClass {
@@ -365,7 +409,34 @@
virtual ::grpc::ServerWriteReactor< ::backup::PullBackupResponse>* PullBackup(
::grpc::CallbackServerContext* /*context*/, const ::backup::PullBackupRequest* /*request*/) { return nullptr; }
};
- typedef WithCallbackMethod_CreateNewBackup<WithCallbackMethod_SendLog<WithCallbackMethod_RecoverBackupKey<WithCallbackMethod_PullBackup<Service > > > > CallbackService;
+ template <class BaseClass>
+ class WithCallbackMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithCallbackMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodCallback(4,
+ new ::grpc::internal::CallbackUnaryHandler< ::backup::AddAttachmentsRequest, ::google::protobuf::Empty>(
+ [this](
+ ::grpc::CallbackServerContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response) { return this->AddAttachments(context, request, response); }));}
+ void SetMessageAllocatorFor_AddAttachments(
+ ::grpc::MessageAllocator< ::backup::AddAttachmentsRequest, ::google::protobuf::Empty>* allocator) {
+ ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4);
+ static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::AddAttachmentsRequest, ::google::protobuf::Empty>*>(handler)
+ ->SetMessageAllocator(allocator);
+ }
+ ~WithCallbackMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ virtual ::grpc::ServerUnaryReactor* AddAttachments(
+ ::grpc::CallbackServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; }
+ };
+ typedef WithCallbackMethod_CreateNewBackup<WithCallbackMethod_SendLog<WithCallbackMethod_RecoverBackupKey<WithCallbackMethod_PullBackup<WithCallbackMethod_AddAttachments<Service > > > > > CallbackService;
typedef CallbackService ExperimentalCallbackService;
template <class BaseClass>
class WithGenericMethod_CreateNewBackup : public BaseClass {
@@ -396,7 +467,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 +507,23 @@
}
};
template <class BaseClass>
+ class WithGenericMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithGenericMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodGeneric(4);
+ }
+ ~WithGenericMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ };
+ template <class BaseClass>
class WithRawMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -467,7 +555,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 +604,26 @@
}
};
template <class BaseClass>
+ class WithRawMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithRawMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodRaw(4);
+ }
+ ~WithRawMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ void RequestAddAttachments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
+ }
+ };
+ template <class BaseClass>
class WithRawCallbackMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -553,7 +661,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,7 +713,56 @@
virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullBackup(
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; }
};
- typedef Service StreamedUnaryService;
+ template <class BaseClass>
+ class WithRawCallbackMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithRawCallbackMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodRawCallback(4,
+ new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ [this](
+ ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->AddAttachments(context, request, response); }));
+ }
+ ~WithRawCallbackMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ virtual ::grpc::ServerUnaryReactor* AddAttachments(
+ ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
+ };
+ template <class BaseClass>
+ class WithStreamedUnaryMethod_AddAttachments : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithStreamedUnaryMethod_AddAttachments() {
+ ::grpc::Service::MarkMethodStreamed(4,
+ new ::grpc::internal::StreamedUnaryHandler<
+ ::backup::AddAttachmentsRequest, ::google::protobuf::Empty>(
+ [this](::grpc::ServerContext* context,
+ ::grpc::ServerUnaryStreamer<
+ ::backup::AddAttachmentsRequest, ::google::protobuf::Empty>* streamer) {
+ return this->StreamedAddAttachments(context,
+ streamer);
+ }));
+ }
+ ~WithStreamedUnaryMethod_AddAttachments() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable regular version of this method
+ ::grpc::Status AddAttachments(::grpc::ServerContext* /*context*/, const ::backup::AddAttachmentsRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ // replace default version of method with streamed unary
+ virtual ::grpc::Status StreamedAddAttachments(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::AddAttachmentsRequest,::google::protobuf::Empty>* server_unary_streamer) = 0;
+ };
+ typedef WithStreamedUnaryMethod_AddAttachments<Service > StreamedUnaryService;
template <class BaseClass>
class WithSplitStreamingMethod_PullBackup : public BaseClass {
private:
@@ -634,7 +791,7 @@
virtual ::grpc::Status StreamedPullBackup(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::backup::PullBackupRequest,::backup::PullBackupResponse>* server_split_streamer) = 0;
};
typedef WithSplitStreamingMethod_PullBackup<Service > SplitStreamedService;
- typedef WithSplitStreamingMethod_PullBackup<Service > StreamedService;
+ typedef WithSplitStreamingMethod_PullBackup<WithStreamedUnaryMethod_AddAttachments<Service > > StreamedService;
};
} // namespace backup
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
@@ -26,6 +26,7 @@
"/backup.BackupService/SendLog",
"/backup.BackupService/RecoverBackupKey",
"/backup.BackupService/PullBackup",
+ "/backup.BackupService/AddAttachments",
};
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_AddAttachments_(BackupService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, 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,29 @@
return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, request, false, nullptr);
}
+::grpc::Status BackupService::Stub::AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::google::protobuf::Empty* response) {
+ return ::grpc::internal::BlockingUnaryCall< ::backup::AddAttachmentsRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_AddAttachments_, context, request, response);
+}
+
+void BackupService::Stub::async::AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
+ ::grpc::internal::CallbackUnaryCall< ::backup::AddAttachmentsRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddAttachments_, context, request, response, std::move(f));
+}
+
+void BackupService::Stub::async::AddAttachments(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
+ ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_AddAttachments_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::PrepareAsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::backup::AddAttachmentsRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_AddAttachments_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::AsyncAddAttachmentsRaw(::grpc::ClientContext* context, const ::backup::AddAttachmentsRequest& request, ::grpc::CompletionQueue* cq) {
+ auto* result =
+ this->PrepareAsyncAddAttachmentsRaw(context, request, cq);
+ result->StartCall();
+ return result;
+}
+
BackupService::Service::Service() {
AddMethod(new ::grpc::internal::RpcServiceMethod(
BackupService_method_names[0],
@@ -119,11 +144,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 +171,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::NORMAL_RPC,
+ new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::AddAttachmentsRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+ [](BackupService::Service* service,
+ ::grpc::ServerContext* ctx,
+ const ::backup::AddAttachmentsRequest* req,
+ ::google::protobuf::Empty* resp) {
+ return service->AddAttachments(ctx, req, resp);
+ }, this)));
}
BackupService::Service::~Service() {
@@ -157,7 +192,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 +212,13 @@
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
+::grpc::Status BackupService::Service::AddAttachments(::grpc::ServerContext* context, const ::backup::AddAttachmentsRequest* request, ::google::protobuf::Empty* response) {
+ (void) context;
+ (void) request;
+ (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[9]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -56,6 +56,9 @@
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 AddAttachmentsRequest;
+struct AddAttachmentsRequestDefaultTypeInternal;
+extern AddAttachmentsRequestDefaultTypeInternal _AddAttachmentsRequest_default_instance_;
class CreateNewBackupRequest;
struct CreateNewBackupRequestDefaultTypeInternal;
extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
@@ -77,8 +80,12 @@
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::AddAttachmentsRequest* Arena::CreateMaybeMessage<::backup::AddAttachmentsRequest>(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 +93,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 +139,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 +222,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 +247,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 +287,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 +307,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 +333,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 +348,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 +741,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<const SendLogResponse*>(
+ &_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<SendLogResponse>(nullptr);
+ }
+
+ SendLogResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<SendLogResponse>(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 {
+ kLogCheckpointFieldNumber = 1,
+ };
+ // string logCheckpoint = 1;
+ void clear_logcheckpoint();
+ const std::string& logcheckpoint() const;
+ void set_logcheckpoint(const std::string& value);
+ void set_logcheckpoint(std::string&& value);
+ void set_logcheckpoint(const char* value);
+ void set_logcheckpoint(const char* value, size_t size);
+ std::string* mutable_logcheckpoint();
+ std::string* release_logcheckpoint();
+ void set_allocated_logcheckpoint(std::string* logcheckpoint);
+ private:
+ const std::string& _internal_logcheckpoint() const;
+ void _internal_set_logcheckpoint(const std::string& value);
+ std::string* _internal_mutable_logcheckpoint();
+ public:
+
+ // @@protoc_insertion_point(class_scope:backup.SendLogResponse)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logcheckpoint_;
+ 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 +928,7 @@
&_RecoverBackupKeyRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 3;
+ 4;
friend void swap(RecoverBackupKeyRequest& a, RecoverBackupKeyRequest& b) {
a.Swap(&b);
@@ -896,7 +1072,7 @@
&_RecoverBackupKeyResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 4;
+ 5;
friend void swap(RecoverBackupKeyResponse& a, RecoverBackupKeyResponse& b) {
a.Swap(&b);
@@ -1040,7 +1216,7 @@
&_PullBackupRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 5;
+ 6;
friend void swap(PullBackupRequest& a, PullBackupRequest& b) {
a.Swap(&b);
@@ -1208,7 +1384,7 @@
&_PullBackupResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
- 6;
+ 7;
friend void swap(PullBackupResponse& a, PullBackupResponse& b) {
a.Swap(&b);
@@ -1346,6 +1522,204 @@
friend struct ::TableStruct_backup_2eproto;
};
+// -------------------------------------------------------------------
+
+class AddAttachmentsRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.AddAttachmentsRequest) */ {
+ public:
+ inline AddAttachmentsRequest() : AddAttachmentsRequest(nullptr) {}
+ virtual ~AddAttachmentsRequest();
+ explicit constexpr AddAttachmentsRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ AddAttachmentsRequest(const AddAttachmentsRequest& from);
+ AddAttachmentsRequest(AddAttachmentsRequest&& from) noexcept
+ : AddAttachmentsRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline AddAttachmentsRequest& operator=(const AddAttachmentsRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline AddAttachmentsRequest& operator=(AddAttachmentsRequest&& 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 AddAttachmentsRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const AddAttachmentsRequest* internal_default_instance() {
+ return reinterpret_cast<const AddAttachmentsRequest*>(
+ &_AddAttachmentsRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(AddAttachmentsRequest& a, AddAttachmentsRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(AddAttachmentsRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(AddAttachmentsRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline AddAttachmentsRequest* New() const final {
+ return CreateMaybeMessage<AddAttachmentsRequest>(nullptr);
+ }
+
+ AddAttachmentsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<AddAttachmentsRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const AddAttachmentsRequest& from);
+ void MergeFrom(const AddAttachmentsRequest& 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(AddAttachmentsRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.AddAttachmentsRequest";
+ }
+ protected:
+ explicit AddAttachmentsRequest(::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,
+ kHoldersFieldNumber = 4,
+ };
+ // 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:
+
+ // string holders = 4;
+ void clear_holders();
+ const std::string& holders() const;
+ void set_holders(const std::string& value);
+ void set_holders(std::string&& value);
+ void set_holders(const char* value);
+ void set_holders(const char* value, size_t size);
+ std::string* mutable_holders();
+ std::string* release_holders();
+ void set_allocated_holders(std::string* holders);
+ private:
+ const std::string& _internal_holders() const;
+ void _internal_set_holders(const std::string& value);
+ std::string* _internal_mutable_holders();
+ public:
+
+ // @@protoc_insertion_point(class_scope:backup.AddAttachmentsRequest)
+ private:
+ class _Internal;
+
+ template <typename T> 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_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr holders_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_backup_2eproto;
+};
// ===================================================================
@@ -1467,7 +1841,117 @@
// @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.userID)
}
-// bytes keyEntropy = 2;
+// 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.deviceID)
+}
+inline void CreateNewBackupRequest::set_deviceid(const char* value,
+ size_t size) {
+ 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(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.deviceID)
+}
+inline std::string* CreateNewBackupRequest::_internal_mutable_deviceid() {
+ if (!_internal_has_deviceid()) {
+ clear_data();
+ set_has_deviceid();
+ data_.deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.deviceid_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* CreateNewBackupRequest::release_deviceid() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.deviceID)
+ if (_internal_has_deviceid()) {
+ clear_has_data();
+ return data_.deviceid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void CreateNewBackupRequest::set_allocated_deviceid(std::string* deviceid) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (deviceid != nullptr) {
+ set_has_deviceid();
+ data_.deviceid_.UnsafeSetDefault(deviceid);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(deviceid);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.deviceID)
+}
+
+// bytes keyEntropy = 3;
inline bool CreateNewBackupRequest::_internal_has_keyentropy() const {
return data_case() == kKeyEntropy;
}
@@ -1577,7 +2061,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 +2171,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 +2810,71 @@
}
// -------------------------------------------------------------------
+// SendLogResponse
+
+// string logCheckpoint = 1;
+inline void SendLogResponse::clear_logcheckpoint() {
+ logcheckpoint_.ClearToEmpty();
+}
+inline const std::string& SendLogResponse::logcheckpoint() const {
+ // @@protoc_insertion_point(field_get:backup.SendLogResponse.logCheckpoint)
+ return _internal_logcheckpoint();
+}
+inline void SendLogResponse::set_logcheckpoint(const std::string& value) {
+ _internal_set_logcheckpoint(value);
+ // @@protoc_insertion_point(field_set:backup.SendLogResponse.logCheckpoint)
+}
+inline std::string* SendLogResponse::mutable_logcheckpoint() {
+ // @@protoc_insertion_point(field_mutable:backup.SendLogResponse.logCheckpoint)
+ return _internal_mutable_logcheckpoint();
+}
+inline const std::string& SendLogResponse::_internal_logcheckpoint() const {
+ return logcheckpoint_.Get();
+}
+inline void SendLogResponse::_internal_set_logcheckpoint(const std::string& value) {
+
+ logcheckpoint_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SendLogResponse::set_logcheckpoint(std::string&& value) {
+
+ logcheckpoint_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.SendLogResponse.logCheckpoint)
+}
+inline void SendLogResponse::set_logcheckpoint(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ logcheckpoint_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.SendLogResponse.logCheckpoint)
+}
+inline void SendLogResponse::set_logcheckpoint(const char* value,
+ size_t size) {
+
+ logcheckpoint_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.SendLogResponse.logCheckpoint)
+}
+inline std::string* SendLogResponse::_internal_mutable_logcheckpoint() {
+
+ return logcheckpoint_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SendLogResponse::release_logcheckpoint() {
+ // @@protoc_insertion_point(field_release:backup.SendLogResponse.logCheckpoint)
+ return logcheckpoint_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SendLogResponse::set_allocated_logcheckpoint(std::string* logcheckpoint) {
+ if (logcheckpoint != nullptr) {
+
+ } else {
+
+ }
+ logcheckpoint_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logcheckpoint,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.SendLogResponse.logCheckpoint)
+}
+
+// -------------------------------------------------------------------
+
// RecoverBackupKeyRequest
// string userID = 1;
@@ -2813,6 +3362,254 @@
inline PullBackupResponse::DataCase PullBackupResponse::data_case() const {
return PullBackupResponse::DataCase(_oneof_case_[0]);
}
+// -------------------------------------------------------------------
+
+// AddAttachmentsRequest
+
+// string userID = 1;
+inline void AddAttachmentsRequest::clear_userid() {
+ userid_.ClearToEmpty();
+}
+inline const std::string& AddAttachmentsRequest::userid() const {
+ // @@protoc_insertion_point(field_get:backup.AddAttachmentsRequest.userID)
+ return _internal_userid();
+}
+inline void AddAttachmentsRequest::set_userid(const std::string& value) {
+ _internal_set_userid(value);
+ // @@protoc_insertion_point(field_set:backup.AddAttachmentsRequest.userID)
+}
+inline std::string* AddAttachmentsRequest::mutable_userid() {
+ // @@protoc_insertion_point(field_mutable:backup.AddAttachmentsRequest.userID)
+ return _internal_mutable_userid();
+}
+inline const std::string& AddAttachmentsRequest::_internal_userid() const {
+ return userid_.Get();
+}
+inline void AddAttachmentsRequest::_internal_set_userid(const std::string& value) {
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void AddAttachmentsRequest::set_userid(std::string&& value) {
+
+ userid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.AddAttachmentsRequest.userID)
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.userID)
+}
+inline void AddAttachmentsRequest::set_userid(const char* value,
+ size_t size) {
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.AddAttachmentsRequest.userID)
+}
+inline std::string* AddAttachmentsRequest::_internal_mutable_userid() {
+
+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* AddAttachmentsRequest::release_userid() {
+ // @@protoc_insertion_point(field_release:backup.AddAttachmentsRequest.userID)
+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.userID)
+}
+
+// string backupID = 2;
+inline void AddAttachmentsRequest::clear_backupid() {
+ backupid_.ClearToEmpty();
+}
+inline const std::string& AddAttachmentsRequest::backupid() const {
+ // @@protoc_insertion_point(field_get:backup.AddAttachmentsRequest.backupID)
+ return _internal_backupid();
+}
+inline void AddAttachmentsRequest::set_backupid(const std::string& value) {
+ _internal_set_backupid(value);
+ // @@protoc_insertion_point(field_set:backup.AddAttachmentsRequest.backupID)
+}
+inline std::string* AddAttachmentsRequest::mutable_backupid() {
+ // @@protoc_insertion_point(field_mutable:backup.AddAttachmentsRequest.backupID)
+ return _internal_mutable_backupid();
+}
+inline const std::string& AddAttachmentsRequest::_internal_backupid() const {
+ return backupid_.Get();
+}
+inline void AddAttachmentsRequest::_internal_set_backupid(const std::string& value) {
+
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void AddAttachmentsRequest::set_backupid(std::string&& value) {
+
+ backupid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.AddAttachmentsRequest.backupID)
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.backupID)
+}
+inline void AddAttachmentsRequest::set_backupid(const char* value,
+ size_t size) {
+
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.AddAttachmentsRequest.backupID)
+}
+inline std::string* AddAttachmentsRequest::_internal_mutable_backupid() {
+
+ return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* AddAttachmentsRequest::release_backupid() {
+ // @@protoc_insertion_point(field_release:backup.AddAttachmentsRequest.backupID)
+ return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.backupID)
+}
+
+// string logID = 3;
+inline void AddAttachmentsRequest::clear_logid() {
+ logid_.ClearToEmpty();
+}
+inline const std::string& AddAttachmentsRequest::logid() const {
+ // @@protoc_insertion_point(field_get:backup.AddAttachmentsRequest.logID)
+ return _internal_logid();
+}
+inline void AddAttachmentsRequest::set_logid(const std::string& value) {
+ _internal_set_logid(value);
+ // @@protoc_insertion_point(field_set:backup.AddAttachmentsRequest.logID)
+}
+inline std::string* AddAttachmentsRequest::mutable_logid() {
+ // @@protoc_insertion_point(field_mutable:backup.AddAttachmentsRequest.logID)
+ return _internal_mutable_logid();
+}
+inline const std::string& AddAttachmentsRequest::_internal_logid() const {
+ return logid_.Get();
+}
+inline void AddAttachmentsRequest::_internal_set_logid(const std::string& value) {
+
+ logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void AddAttachmentsRequest::set_logid(std::string&& value) {
+
+ logid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.AddAttachmentsRequest.logID)
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.logID)
+}
+inline void AddAttachmentsRequest::set_logid(const char* value,
+ size_t size) {
+
+ logid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.AddAttachmentsRequest.logID)
+}
+inline std::string* AddAttachmentsRequest::_internal_mutable_logid() {
+
+ return logid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* AddAttachmentsRequest::release_logid() {
+ // @@protoc_insertion_point(field_release:backup.AddAttachmentsRequest.logID)
+ return logid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void AddAttachmentsRequest::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.AddAttachmentsRequest.logID)
+}
+
+// string holders = 4;
+inline void AddAttachmentsRequest::clear_holders() {
+ holders_.ClearToEmpty();
+}
+inline const std::string& AddAttachmentsRequest::holders() const {
+ // @@protoc_insertion_point(field_get:backup.AddAttachmentsRequest.holders)
+ return _internal_holders();
+}
+inline void AddAttachmentsRequest::set_holders(const std::string& value) {
+ _internal_set_holders(value);
+ // @@protoc_insertion_point(field_set:backup.AddAttachmentsRequest.holders)
+}
+inline std::string* AddAttachmentsRequest::mutable_holders() {
+ // @@protoc_insertion_point(field_mutable:backup.AddAttachmentsRequest.holders)
+ return _internal_mutable_holders();
+}
+inline const std::string& AddAttachmentsRequest::_internal_holders() const {
+ return holders_.Get();
+}
+inline void AddAttachmentsRequest::_internal_set_holders(const std::string& value) {
+
+ holders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void AddAttachmentsRequest::set_holders(std::string&& value) {
+
+ holders_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.AddAttachmentsRequest.holders)
+}
+inline void AddAttachmentsRequest::set_holders(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ holders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.AddAttachmentsRequest.holders)
+}
+inline void AddAttachmentsRequest::set_holders(const char* value,
+ size_t size) {
+
+ holders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.AddAttachmentsRequest.holders)
+}
+inline std::string* AddAttachmentsRequest::_internal_mutable_holders() {
+
+ return holders_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* AddAttachmentsRequest::release_holders() {
+ // @@protoc_insertion_point(field_release:backup.AddAttachmentsRequest.holders)
+ return holders_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void AddAttachmentsRequest::set_allocated_holders(std::string* holders) {
+ if (holders != nullptr) {
+
+ } else {
+
+ }
+ holders_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), holders,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.AddAttachmentsRequest.holders)
+}
+
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
@@ -2828,6 +3625,10 @@
// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
// @@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)
+ : logcheckpoint_(&::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,23 @@
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
+constexpr AddAttachmentsRequest::AddAttachmentsRequest(
+ ::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)
+ , holders_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct AddAttachmentsRequestDefaultTypeInternal {
+ constexpr AddAttachmentsRequestDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~AddAttachmentsRequestDefaultTypeInternal() {}
+ union {
+ AddAttachmentsRequest _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AddAttachmentsRequestDefaultTypeInternal _AddAttachmentsRequest_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[9];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_backup_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_backup_2eproto = nullptr;
@@ -117,6 +144,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 +163,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, logcheckpoint_),
+ ~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
@@ -161,59 +195,78 @@
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, userid_),
+ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, backupid_),
+ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, logid_),
+ PROTOBUF_FIELD_OFFSET(::backup::AddAttachmentsRequest, holders_),
};
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::AddAttachmentsRequest)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_CreateNewBackupResponse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SendLogRequest_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SendLogResponse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_RecoverBackupKeyResponse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupResponse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_AddAttachmentsRequest_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"
- "\"\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"
+ "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\025\n\rlogCheckpoint\030\001 \001(\t\")\n\027Re"
+ "coverBackupKeyRequest\022\016\n\006userID\030\001 \001(\t\",\n"
+ "\030RecoverBackupKeyResponse\022\020\n\010backupID\030\004 "
+ "\001(\t\"5\n\021PullBackupRequest\022\016\n\006userID\030\001 \001(\t"
+ "\022\020\n\010backupID\030\002 \001(\t\"K\n\022PullBackupResponse"
+ "\022\031\n\017compactionChunk\030\001 \001(\014H\000\022\022\n\010logChunk\030"
+ "\002 \001(\014H\000B\006\n\004data\"Y\n\025AddAttachmentsRequest"
+ "\022\016\n\006userID\030\001 \001(\t\022\020\n\010backupID\030\002 \001(\t\022\r\n\005lo"
+ "gID\030\003 \001(\t\022\017\n\007holders\030\004 \001(\t2\232\003\n\rBackupSer"
+ "vice\022X\n\017CreateNewBackup\022\036.backup.CreateN"
+ "ewBackupRequest\032\037.backup.CreateNewBackup"
+ "Response\"\000(\0010\001\022>\n\007SendLog\022\026.backup.SendL"
+ "ogRequest\032\027.backup.SendLogResponse\"\000(\001\022["
+ "\n\020RecoverBackupKey\022\037.backup.RecoverBacku"
+ "pKeyRequest\032 .backup.RecoverBackupKeyRes"
+ "ponse\"\000(\0010\001\022G\n\nPullBackup\022\031.backup.PullB"
+ "ackupRequest\032\032.backup.PullBackupResponse"
+ "\"\0000\001\022I\n\016AddAttachments\022\035.backup.AddAttac"
+ "hmentsRequest\032\026.google.protobuf.Empty\"\000b"
+ "\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, 1127, descriptor_table_protodef_backup_2eproto, "backup.proto",
+ &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 9,
schemas, file_default_instances, TableStruct_backup_2eproto::offsets,
file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto,
};
@@ -248,6 +301,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 +358,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 +408,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 +479,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<int>(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 +531,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 +599,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 +1189,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_);
+ logcheckpoint_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_logcheckpoint().empty()) {
+ logcheckpoint_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logcheckpoint(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.SendLogResponse)
+}
+
+void SendLogResponse::SharedCtor() {
+logcheckpoint_.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);
+ logcheckpoint_.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;
+
+ logcheckpoint_.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 logCheckpoint = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_logcheckpoint();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogResponse.logCheckpoint"));
+ 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 logCheckpoint = 1;
+ if (this->logcheckpoint().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_logcheckpoint().data(), static_cast<int>(this->_internal_logcheckpoint().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.SendLogResponse.logCheckpoint");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_logcheckpoint(), 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 logCheckpoint = 1;
+ if (this->logcheckpoint().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_logcheckpoint());
+ }
+
+ 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<SendLogResponse>(
+ &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.logcheckpoint().size() > 0) {
+ _internal_set_logcheckpoint(from._internal_logcheckpoint());
+ }
+}
+
+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_);
+ logcheckpoint_.Swap(&other->logcheckpoint_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SendLogResponse::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
// ===================================================================
class RecoverBackupKeyRequest::_Internal {
@@ -1998,6 +2289,320 @@
}
+// ===================================================================
+
+class AddAttachmentsRequest::_Internal {
+ public:
+};
+
+AddAttachmentsRequest::AddAttachmentsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.AddAttachmentsRequest)
+}
+AddAttachmentsRequest::AddAttachmentsRequest(const AddAttachmentsRequest& 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());
+ }
+ holders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_holders().empty()) {
+ holders_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_holders(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.AddAttachmentsRequest)
+}
+
+void AddAttachmentsRequest::SharedCtor() {
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+logid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+holders_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+AddAttachmentsRequest::~AddAttachmentsRequest() {
+ // @@protoc_insertion_point(destructor:backup.AddAttachmentsRequest)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void AddAttachmentsRequest::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());
+ holders_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void AddAttachmentsRequest::ArenaDtor(void* object) {
+ AddAttachmentsRequest* _this = reinterpret_cast< AddAttachmentsRequest* >(object);
+ (void)_this;
+}
+void AddAttachmentsRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AddAttachmentsRequest::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void AddAttachmentsRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.AddAttachmentsRequest)
+ ::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();
+ holders_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AddAttachmentsRequest::_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.AddAttachmentsRequest.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.AddAttachmentsRequest.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.AddAttachmentsRequest.logID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string holders = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ auto str = _internal_mutable_holders();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.AddAttachmentsRequest.holders"));
+ 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* AddAttachmentsRequest::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.AddAttachmentsRequest)
+ ::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<int>(this->_internal_userid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.AddAttachmentsRequest.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<int>(this->_internal_backupid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.AddAttachmentsRequest.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<int>(this->_internal_logid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.AddAttachmentsRequest.logID");
+ target = stream->WriteStringMaybeAliased(
+ 3, this->_internal_logid(), target);
+ }
+
+ // string holders = 4;
+ if (this->holders().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_holders().data(), static_cast<int>(this->_internal_holders().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.AddAttachmentsRequest.holders");
+ target = stream->WriteStringMaybeAliased(
+ 4, this->_internal_holders(), 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.AddAttachmentsRequest)
+ return target;
+}
+
+size_t AddAttachmentsRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.AddAttachmentsRequest)
+ 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());
+ }
+
+ // string holders = 4;
+ if (this->holders().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_holders());
+ }
+
+ 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 AddAttachmentsRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.AddAttachmentsRequest)
+ GOOGLE_DCHECK_NE(&from, this);
+ const AddAttachmentsRequest* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<AddAttachmentsRequest>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.AddAttachmentsRequest)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.AddAttachmentsRequest)
+ MergeFrom(*source);
+ }
+}
+
+void AddAttachmentsRequest::MergeFrom(const AddAttachmentsRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.AddAttachmentsRequest)
+ 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());
+ }
+ if (from.holders().size() > 0) {
+ _internal_set_holders(from._internal_holders());
+ }
+}
+
+void AddAttachmentsRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.AddAttachmentsRequest)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void AddAttachmentsRequest::CopyFrom(const AddAttachmentsRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.AddAttachmentsRequest)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool AddAttachmentsRequest::IsInitialized() const {
+ return true;
+}
+
+void AddAttachmentsRequest::InternalSwap(AddAttachmentsRequest* 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());
+ holders_.Swap(&other->holders_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AddAttachmentsRequest::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
// @@protoc_insertion_point(namespace_scope)
} // namespace backup
PROTOBUF_NAMESPACE_OPEN
@@ -2010,6 +2615,9 @@
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);
}
@@ -2022,6 +2630,9 @@
template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) {
return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena);
}
+template<> PROTOBUF_NOINLINE ::backup::AddAttachmentsRequest* Arena::CreateMaybeMessage< ::backup::AddAttachmentsRequest >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::AddAttachmentsRequest >(arena);
+}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
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 AddAttachments(AddAttachmentsRequest) returns (google.protobuf.Empty) {}
}
// CreateNewBackup
@@ -79,3 +80,12 @@
bytes logChunk = 2;
}
}
+
+// AddAttachment
+
+message AddAttachmentsRequest {
+ string userID = 1;
+ string backupID = 2;
+ string logID = 3;
+ string holders = 4;
+}
File Metadata
Details
Attached
Mime Type
text/plain
Expires
Fri, Dec 27, 6:26 AM (8 h, 27 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2711315
Default Alt Text
D4080.id13140.diff (118 KB)
Attached To
Mode
D4080: [services] Backup - Add AddAttachment method
Attached
Detach File
Event Timeline
Log In to Comment