Page MenuHomePhabricator
Files F3540586

D4080.id13053.diff
No OneTemporary
Actions

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

File Metadata

Mime Type
text/plain
Expires
Fri, Dec 27, 5:29 AM (8 h, 13 s)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2710747
Default Alt Text
D4080.id13053.diff (141 KB)

Event Timeline