Page MenuHomePhabricator
Files F3728917

D3076.diff
No OneTemporary
Actions

D3076.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.h
@@ -35,107 +35,113 @@
class StubInterface {
public:
virtual ~StubInterface() {}
- std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
- return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
}
- std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
}
- std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
}
- virtual ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) = 0;
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+ return std::unique_ptr< ::grpc::ClientWriterInterface< ::backup::SendLogRequest>>(SendLogRaw(context, response));
}
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
}
- virtual ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) = 0;
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
}
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
}
- std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
- return std::unique_ptr< ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
}
- std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
}
- std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
}
class async_interface {
public:
virtual ~async_interface() {}
- virtual void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) = 0;
- virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
- virtual void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
- virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) = 0;
- virtual void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
- virtual void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) = 0;
+ virtual void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) = 0;
+ virtual void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) = 0;
+ virtual void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) = 0;
+ virtual void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) = 0;
};
typedef class async_interface experimental_async_interface;
virtual class async_interface* async() { return nullptr; }
class async_interface* experimental_async() { return async(); }
private:
- virtual ::grpc::ClientWriterInterface< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
- virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
- virtual ::grpc::ClientAsyncWriterInterface< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientReaderInterface< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) = 0;
- virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
- virtual ::grpc::ClientAsyncReaderInterface< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) = 0;
+ virtual ::grpc::ClientReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
+ virtual ::grpc::ClientWriterInterface< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) = 0;
+ virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) = 0;
+ virtual ::grpc::ClientAsyncWriterInterface< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) = 0;
+ virtual ::grpc::ClientReaderWriterInterface< ::backup::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::ClientReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
};
class Stub final : public StubInterface {
public:
Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
- std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>> ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
- return std::unique_ptr< ::grpc::ClientWriter< ::backup::ResetKeyRequest>>(ResetKeyRaw(context, response));
+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> CreateNewBackup(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(CreateNewBackupRaw(context));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> AsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(AsyncCreateNewBackupRaw(context, cq, tag));
}
- std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> AsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(AsyncResetKeyRaw(context, response, cq, tag));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>> PrepareAsyncCreateNewBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>>(PrepareAsyncCreateNewBackupRaw(context, cq));
}
- std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>> PrepareAsyncResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>>(PrepareAsyncResetKeyRaw(context, response, cq));
+ std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>> SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+ return std::unique_ptr< ::grpc::ClientWriter< ::backup::SendLogRequest>>(SendLogRaw(context, response));
}
- ::grpc::Status SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) override;
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendLogRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> AsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(AsyncSendLogRaw(context, response, cq, tag));
}
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendLogRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>> PrepareAsyncSendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>>(PrepareAsyncSendLogRaw(context, response, cq));
}
- ::grpc::Status PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) override;
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> AsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(AsyncPullBackupKeyRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> RecoverBackupKey(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(RecoverBackupKeyRaw(context));
}
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>> PrepareAsyncPullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>>(PrepareAsyncPullBackupKeyRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> AsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(AsyncRecoverBackupKeyRaw(context, cq, tag));
}
- std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>> PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
- return std::unique_ptr< ::grpc::ClientReader< ::backup::PullCompactionResponse>>(PullCompactionRaw(context, request));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>> PrepareAsyncRecoverBackupKey(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>>(PrepareAsyncRecoverBackupKeyRaw(context, cq));
}
- std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> AsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(AsyncPullCompactionRaw(context, request, cq, tag));
+ std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PullBackup(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PullBackupRaw(context));
}
- std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>> PrepareAsyncPullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>>(PrepareAsyncPullCompactionRaw(context, request, cq));
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> AsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(AsyncPullBackupRaw(context, cq, tag));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>> PrepareAsyncPullBackup(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>>(PrepareAsyncPullBackupRaw(context, cq));
}
class async final :
public StubInterface::async_interface {
public:
- void ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) override;
- void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
- void SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
- void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)>) override;
- void PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
- void PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) override;
+ void CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) override;
+ void SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) override;
+ void RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) override;
+ void PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) override;
private:
friend class Stub;
explicit async(Stub* stub): stub_(stub) { }
@@ -147,20 +153,22 @@
private:
std::shared_ptr< ::grpc::ChannelInterface> channel_;
class async async_stub_{this};
- ::grpc::ClientWriter< ::backup::ResetKeyRequest>* ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
- ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
- ::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientReader< ::backup::PullCompactionResponse>* PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) override;
- ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
- ::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) override;
- const ::grpc::internal::RpcMethod rpcmethod_ResetKey_;
+ ::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackupRaw(::grpc::ClientContext* context) override;
+ ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+ ::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+ ::grpc::ClientWriter< ::backup::SendLogRequest>* SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) override;
+ ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) override;
+ ::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) override;
+ ::grpc::ClientReaderWriter< ::backup::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::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackupRaw(::grpc::ClientContext* context) override;
+ ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+ ::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
+ const ::grpc::internal::RpcMethod rpcmethod_CreateNewBackup_;
const ::grpc::internal::RpcMethod rpcmethod_SendLog_;
- const ::grpc::internal::RpcMethod rpcmethod_PullBackupKey_;
- const ::grpc::internal::RpcMethod rpcmethod_PullCompaction_;
+ const ::grpc::internal::RpcMethod rpcmethod_RecoverBackupKey_;
+ const ::grpc::internal::RpcMethod rpcmethod_PullBackup_;
};
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
@@ -168,29 +176,29 @@
public:
Service();
virtual ~Service();
- virtual ::grpc::Status ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response);
- virtual ::grpc::Status SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response);
- virtual ::grpc::Status PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response);
- virtual ::grpc::Status PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer);
+ virtual ::grpc::Status CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream);
+ virtual ::grpc::Status SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response);
+ virtual ::grpc::Status RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream);
+ virtual ::grpc::Status PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream);
};
template <class BaseClass>
- class WithAsyncMethod_ResetKey : public BaseClass {
+ class WithAsyncMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithAsyncMethod_ResetKey() {
+ WithAsyncMethod_CreateNewBackup() {
::grpc::Service::MarkMethodAsync(0);
}
- ~WithAsyncMethod_ResetKey() override {
+ ~WithAsyncMethod_CreateNewBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::ResetKeyRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
+ void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
@@ -205,76 +213,77 @@
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestSendLog(::grpc::ServerContext* context, ::backup::SendLogRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+ void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::google::protobuf::Empty, ::backup::SendLogRequest>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
- class WithAsyncMethod_PullBackupKey : public BaseClass {
+ class WithAsyncMethod_RecoverBackupKey : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithAsyncMethod_PullBackupKey() {
+ WithAsyncMethod_RecoverBackupKey() {
::grpc::Service::MarkMethodAsync(2);
}
- ~WithAsyncMethod_PullBackupKey() override {
+ ~WithAsyncMethod_RecoverBackupKey() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestPullBackupKey(::grpc::ServerContext* context, ::backup::PullBackupKeyRequest* request, ::grpc::ServerAsyncResponseWriter< ::backup::PullBackupKeyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+ void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
- class WithAsyncMethod_PullCompaction : public BaseClass {
+ class WithAsyncMethod_PullBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithAsyncMethod_PullCompaction() {
+ WithAsyncMethod_PullBackup() {
::grpc::Service::MarkMethodAsync(3);
}
- ~WithAsyncMethod_PullCompaction() override {
+ ~WithAsyncMethod_PullBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+ ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestPullCompaction(::grpc::ServerContext* context, ::backup::PullCompactionRequest* request, ::grpc::ServerAsyncWriter< ::backup::PullCompactionResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
+ void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
}
};
- typedef WithAsyncMethod_ResetKey<WithAsyncMethod_SendLog<WithAsyncMethod_PullBackupKey<WithAsyncMethod_PullCompaction<Service > > > > AsyncService;
+ typedef WithAsyncMethod_CreateNewBackup<WithAsyncMethod_SendLog<WithAsyncMethod_RecoverBackupKey<WithAsyncMethod_PullBackup<Service > > > > AsyncService;
template <class BaseClass>
- class WithCallbackMethod_ResetKey : public BaseClass {
+ class WithCallbackMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithCallbackMethod_ResetKey() {
+ WithCallbackMethod_CreateNewBackup() {
::grpc::Service::MarkMethodCallback(0,
- new ::grpc::internal::CallbackClientStreamingHandler< ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
+ new ::grpc::internal::CallbackBidiHandler< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
[this](
- ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->ResetKey(context, response); }));
+ ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
}
- ~WithCallbackMethod_ResetKey() override {
+ ~WithCallbackMethod_CreateNewBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerReadReactor< ::backup::ResetKeyRequest>* ResetKey(
- ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerBidiReactor< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* CreateNewBackup(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
template <class BaseClass>
class WithCallbackMethod_SendLog : public BaseClass {
@@ -283,90 +292,82 @@
public:
WithCallbackMethod_SendLog() {
::grpc::Service::MarkMethodCallback(1,
- new ::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
+ new ::grpc::internal::CallbackClientStreamingHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>(
[this](
- ::grpc::CallbackServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) { return this->SendLog(context, request, response); }));}
- void SetMessageAllocatorFor_SendLog(
- ::grpc::MessageAllocator< ::backup::SendLogRequest, ::google::protobuf::Empty>* allocator) {
- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
- static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::SendLogRequest, ::google::protobuf::Empty>*>(handler)
- ->SetMessageAllocator(allocator);
+ ::grpc::CallbackServerContext* context, ::google::protobuf::Empty* response) { return this->SendLog(context, response); }));
}
~WithCallbackMethod_SendLog() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerUnaryReactor* SendLog(
- ::grpc::CallbackServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerReadReactor< ::backup::SendLogRequest>* SendLog(
+ ::grpc::CallbackServerContext* /*context*/, ::google::protobuf::Empty* /*response*/) { return nullptr; }
};
template <class BaseClass>
- class WithCallbackMethod_PullBackupKey : public BaseClass {
+ class WithCallbackMethod_RecoverBackupKey : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithCallbackMethod_PullBackupKey() {
+ WithCallbackMethod_RecoverBackupKey() {
::grpc::Service::MarkMethodCallback(2,
- new ::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
+ new ::grpc::internal::CallbackBidiHandler< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
[this](
- ::grpc::CallbackServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) { return this->PullBackupKey(context, request, response); }));}
- void SetMessageAllocatorFor_PullBackupKey(
- ::grpc::MessageAllocator< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* allocator) {
- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
- static_cast<::grpc::internal::CallbackUnaryHandler< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>*>(handler)
- ->SetMessageAllocator(allocator);
- }
- ~WithCallbackMethod_PullBackupKey() override {
+ ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
+ }
+ ~WithCallbackMethod_RecoverBackupKey() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerUnaryReactor* PullBackupKey(
- ::grpc::CallbackServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerBidiReactor< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* RecoverBackupKey(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
template <class BaseClass>
- class WithCallbackMethod_PullCompaction : public BaseClass {
+ class WithCallbackMethod_PullBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithCallbackMethod_PullCompaction() {
+ WithCallbackMethod_PullBackup() {
::grpc::Service::MarkMethodCallback(3,
- new ::grpc::internal::CallbackServerStreamingHandler< ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
+ new ::grpc::internal::CallbackBidiHandler< ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
[this](
- ::grpc::CallbackServerContext* context, const ::backup::PullCompactionRequest* request) { return this->PullCompaction(context, request); }));
+ ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
}
- ~WithCallbackMethod_PullCompaction() override {
+ ~WithCallbackMethod_PullBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+ ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerWriteReactor< ::backup::PullCompactionResponse>* PullCompaction(
- ::grpc::CallbackServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/) { return nullptr; }
+ virtual ::grpc::ServerBidiReactor< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* PullBackup(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
- typedef WithCallbackMethod_ResetKey<WithCallbackMethod_SendLog<WithCallbackMethod_PullBackupKey<WithCallbackMethod_PullCompaction<Service > > > > CallbackService;
+ typedef WithCallbackMethod_CreateNewBackup<WithCallbackMethod_SendLog<WithCallbackMethod_RecoverBackupKey<WithCallbackMethod_PullBackup<Service > > > > CallbackService;
typedef CallbackService ExperimentalCallbackService;
template <class BaseClass>
- class WithGenericMethod_ResetKey : public BaseClass {
+ class WithGenericMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithGenericMethod_ResetKey() {
+ WithGenericMethod_CreateNewBackup() {
::grpc::Service::MarkMethodGeneric(0);
}
- ~WithGenericMethod_ResetKey() override {
+ ~WithGenericMethod_CreateNewBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
@@ -383,63 +384,63 @@
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
};
template <class BaseClass>
- class WithGenericMethod_PullBackupKey : public BaseClass {
+ class WithGenericMethod_RecoverBackupKey : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithGenericMethod_PullBackupKey() {
+ WithGenericMethod_RecoverBackupKey() {
::grpc::Service::MarkMethodGeneric(2);
}
- ~WithGenericMethod_PullBackupKey() override {
+ ~WithGenericMethod_RecoverBackupKey() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
};
template <class BaseClass>
- class WithGenericMethod_PullCompaction : public BaseClass {
+ class WithGenericMethod_PullBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithGenericMethod_PullCompaction() {
+ WithGenericMethod_PullBackup() {
::grpc::Service::MarkMethodGeneric(3);
}
- ~WithGenericMethod_PullCompaction() override {
+ ~WithGenericMethod_PullBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+ ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
};
template <class BaseClass>
- class WithRawMethod_ResetKey : public BaseClass {
+ class WithRawMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawMethod_ResetKey() {
+ WithRawMethod_CreateNewBackup() {
::grpc::Service::MarkMethodRaw(0);
}
- ~WithRawMethod_ResetKey() override {
+ ~WithRawMethod_CreateNewBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestResetKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncClientStreaming(0, context, reader, new_call_cq, notification_cq, tag);
+ void RequestCreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(0, context, stream, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
@@ -454,75 +455,76 @@
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestSendLog(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+ void RequestSendLog(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncClientStreaming(1, context, reader, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
- class WithRawMethod_PullBackupKey : public BaseClass {
+ class WithRawMethod_RecoverBackupKey : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawMethod_PullBackupKey() {
+ WithRawMethod_RecoverBackupKey() {
::grpc::Service::MarkMethodRaw(2);
}
- ~WithRawMethod_PullBackupKey() override {
+ ~WithRawMethod_RecoverBackupKey() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestPullBackupKey(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+ void RequestRecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(2, context, stream, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
- class WithRawMethod_PullCompaction : public BaseClass {
+ class WithRawMethod_PullBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawMethod_PullCompaction() {
+ WithRawMethod_PullBackup() {
::grpc::Service::MarkMethodRaw(3);
}
- ~WithRawMethod_PullCompaction() override {
+ ~WithRawMethod_PullBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+ ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- void RequestPullCompaction(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncServerStreaming(3, context, request, writer, new_call_cq, notification_cq, tag);
+ void RequestPullBackup(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
- class WithRawCallbackMethod_ResetKey : public BaseClass {
+ class WithRawCallbackMethod_CreateNewBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawCallbackMethod_ResetKey() {
+ WithRawCallbackMethod_CreateNewBackup() {
::grpc::Service::MarkMethodRawCallback(0,
- new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
[this](
- ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->ResetKey(context, response); }));
+ ::grpc::CallbackServerContext* context) { return this->CreateNewBackup(context); }));
}
- ~WithRawCallbackMethod_ResetKey() override {
+ ~WithRawCallbackMethod_CreateNewBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status ResetKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::ResetKeyRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status CreateNewBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* ResetKey(
- ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* CreateNewBackup(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
template <class BaseClass>
class WithRawCallbackMethod_SendLog : public BaseClass {
@@ -531,149 +533,70 @@
public:
WithRawCallbackMethod_SendLog() {
::grpc::Service::MarkMethodRawCallback(1,
- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ new ::grpc::internal::CallbackClientStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
[this](
- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->SendLog(context, request, response); }));
+ ::grpc::CallbackServerContext* context, ::grpc::ByteBuffer* response) { return this->SendLog(context, response); }));
}
~WithRawCallbackMethod_SendLog() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
+ ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< ::backup::SendLogRequest>* /*reader*/, ::google::protobuf::Empty* /*response*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerUnaryReactor* SendLog(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerReadReactor< ::grpc::ByteBuffer>* SendLog(
+ ::grpc::CallbackServerContext* /*context*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
};
template <class BaseClass>
- class WithRawCallbackMethod_PullBackupKey : public BaseClass {
+ class WithRawCallbackMethod_RecoverBackupKey : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawCallbackMethod_PullBackupKey() {
+ WithRawCallbackMethod_RecoverBackupKey() {
::grpc::Service::MarkMethodRawCallback(2,
- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
[this](
- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->PullBackupKey(context, request, response); }));
+ ::grpc::CallbackServerContext* context) { return this->RecoverBackupKey(context); }));
}
- ~WithRawCallbackMethod_PullBackupKey() override {
+ ~WithRawCallbackMethod_RecoverBackupKey() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
+ ::grpc::Status RecoverBackupKey(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- virtual ::grpc::ServerUnaryReactor* PullBackupKey(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* RecoverBackupKey(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
template <class BaseClass>
- class WithRawCallbackMethod_PullCompaction : public BaseClass {
+ class WithRawCallbackMethod_PullBackup : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
public:
- WithRawCallbackMethod_PullCompaction() {
+ WithRawCallbackMethod_PullBackup() {
::grpc::Service::MarkMethodRawCallback(3,
- new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
[this](
- ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->PullCompaction(context, request); }));
+ ::grpc::CallbackServerContext* context) { return this->PullBackup(context); }));
}
- ~WithRawCallbackMethod_PullCompaction() override {
+ ~WithRawCallbackMethod_PullBackup() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* PullCompaction(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithStreamedUnaryMethod_SendLog : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithStreamedUnaryMethod_SendLog() {
- ::grpc::Service::MarkMethodStreamed(1,
- new ::grpc::internal::StreamedUnaryHandler<
- ::backup::SendLogRequest, ::google::protobuf::Empty>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerUnaryStreamer<
- ::backup::SendLogRequest, ::google::protobuf::Empty>* streamer) {
- return this->StreamedSendLog(context,
- streamer);
- }));
- }
- ~WithStreamedUnaryMethod_SendLog() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status SendLog(::grpc::ServerContext* /*context*/, const ::backup::SendLogRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- // replace default version of method with streamed unary
- virtual ::grpc::Status StreamedSendLog(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::SendLogRequest,::google::protobuf::Empty>* server_unary_streamer) = 0;
- };
- template <class BaseClass>
- class WithStreamedUnaryMethod_PullBackupKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithStreamedUnaryMethod_PullBackupKey() {
- ::grpc::Service::MarkMethodStreamed(2,
- new ::grpc::internal::StreamedUnaryHandler<
- ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerUnaryStreamer<
- ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse>* streamer) {
- return this->StreamedPullBackupKey(context,
- streamer);
- }));
- }
- ~WithStreamedUnaryMethod_PullBackupKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status PullBackupKey(::grpc::ServerContext* /*context*/, const ::backup::PullBackupKeyRequest* /*request*/, ::backup::PullBackupKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- // replace default version of method with streamed unary
- virtual ::grpc::Status StreamedPullBackupKey(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::backup::PullBackupKeyRequest,::backup::PullBackupKeyResponse>* server_unary_streamer) = 0;
- };
- typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<Service > > StreamedUnaryService;
- template <class BaseClass>
- class WithSplitStreamingMethod_PullCompaction : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithSplitStreamingMethod_PullCompaction() {
- ::grpc::Service::MarkMethodStreamed(3,
- new ::grpc::internal::SplitServerStreamingHandler<
- ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerSplitStreamer<
- ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>* streamer) {
- return this->StreamedPullCompaction(context,
- streamer);
- }));
- }
- ~WithSplitStreamingMethod_PullCompaction() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status PullCompaction(::grpc::ServerContext* /*context*/, const ::backup::PullCompactionRequest* /*request*/, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* /*writer*/) override {
+ ::grpc::Status PullBackup(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* /*stream*/) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
- // replace default version of method with split streamed
- virtual ::grpc::Status StreamedPullCompaction(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::backup::PullCompactionRequest,::backup::PullCompactionResponse>* server_split_streamer) = 0;
+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* PullBackup(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
};
- typedef WithSplitStreamingMethod_PullCompaction<Service > SplitStreamedService;
- typedef WithStreamedUnaryMethod_SendLog<WithStreamedUnaryMethod_PullBackupKey<WithSplitStreamingMethod_PullCompaction<Service > > > StreamedService;
+ typedef Service StreamedUnaryService;
+ typedef Service SplitStreamedService;
+ typedef Service StreamedService;
};
} // namespace backup
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.grpc.pb.cc
@@ -22,10 +22,10 @@
namespace backup {
static const char* BackupService_method_names[] = {
- "/backup.BackupService/ResetKey",
+ "/backup.BackupService/CreateNewBackup",
"/backup.BackupService/SendLog",
- "/backup.BackupService/PullBackupKey",
- "/backup.BackupService/PullCompaction",
+ "/backup.BackupService/RecoverBackupKey",
+ "/backup.BackupService/PullBackup",
};
std::unique_ptr< BackupService::Stub> BackupService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
@@ -35,161 +35,144 @@
}
BackupService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
- : channel_(channel), rpcmethod_ResetKey_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
- , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
- , rpcmethod_PullBackupKey_(BackupService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
- , rpcmethod_PullCompaction_(BackupService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
+ : channel_(channel), rpcmethod_CreateNewBackup_(BackupService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
+ , rpcmethod_SendLog_(BackupService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::CLIENT_STREAMING, channel)
+ , rpcmethod_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::BIDI_STREAMING, channel)
{}
-::grpc::ClientWriter< ::backup::ResetKeyRequest>* BackupService::Stub::ResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
- return ::grpc::internal::ClientWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), rpcmethod_ResetKey_, context, response);
+::grpc::ClientReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::CreateNewBackupRaw(::grpc::ClientContext* context) {
+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), rpcmethod_CreateNewBackup_, context);
}
-void BackupService::Stub::async::ResetKey(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::ResetKeyRequest>* reactor) {
- ::grpc::internal::ClientCallbackWriterFactory< ::backup::ResetKeyRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_ResetKey_, context, response, reactor);
+void BackupService::Stub::async::CreateNewBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>* reactor) {
+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::CreateNewBackupRequest,::backup::CreateNewBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_CreateNewBackup_, context, reactor);
}
-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::AsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
- return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, true, tag);
+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::AsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, true, tag);
}
-::grpc::ClientAsyncWriter< ::backup::ResetKeyRequest>* BackupService::Stub::PrepareAsyncResetKeyRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncWriterFactory< ::backup::ResetKeyRequest>::Create(channel_.get(), cq, rpcmethod_ResetKey_, context, response, false, nullptr);
+::grpc::ClientAsyncReaderWriter< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>* BackupService::Stub::PrepareAsyncCreateNewBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>::Create(channel_.get(), cq, rpcmethod_CreateNewBackup_, context, false, nullptr);
}
-::grpc::Status BackupService::Stub::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::google::protobuf::Empty* response) {
- return ::grpc::internal::BlockingUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_SendLog_, context, request, response);
+::grpc::ClientWriter< ::backup::SendLogRequest>* BackupService::Stub::SendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response) {
+ return ::grpc::internal::ClientWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), rpcmethod_SendLog_, context, response);
}
-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)> f) {
- ::grpc::internal::CallbackUnaryCall< ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, std::move(f));
+void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::ClientWriteReactor< ::backup::SendLogRequest>* reactor) {
+ ::grpc::internal::ClientCallbackWriterFactory< ::backup::SendLogRequest>::Create(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, response, reactor);
}
-void BackupService::Stub::async::SendLog(::grpc::ClientContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) {
- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_SendLog_, context, request, response, reactor);
+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq, void* tag) {
+ return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, true, tag);
}
-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::google::protobuf::Empty, ::backup::SendLogRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_SendLog_, context, request);
+::grpc::ClientAsyncWriter< ::backup::SendLogRequest>* BackupService::Stub::PrepareAsyncSendLogRaw(::grpc::ClientContext* context, ::google::protobuf::Empty* response, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncWriterFactory< ::backup::SendLogRequest>::Create(channel_.get(), cq, rpcmethod_SendLog_, context, response, false, nullptr);
}
-::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* BackupService::Stub::AsyncSendLogRaw(::grpc::ClientContext* context, const ::backup::SendLogRequest& request, ::grpc::CompletionQueue* cq) {
- auto* result =
- this->PrepareAsyncSendLogRaw(context, request, cq);
- result->StartCall();
- return result;
+::grpc::ClientReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::RecoverBackupKeyRaw(::grpc::ClientContext* context) {
+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), rpcmethod_RecoverBackupKey_, context);
}
-::grpc::Status BackupService::Stub::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::backup::PullBackupKeyResponse* response) {
- return ::grpc::internal::BlockingUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_PullBackupKey_, context, request, response);
+void BackupService::Stub::async::RecoverBackupKey(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>* reactor) {
+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::RecoverBackupKeyRequest,::backup::RecoverBackupKeyResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_RecoverBackupKey_, context, reactor);
}
-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, std::function<void(::grpc::Status)> f) {
- ::grpc::internal::CallbackUnaryCall< ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, std::move(f));
+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::AsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, true, tag);
}
-void BackupService::Stub::async::PullBackupKey(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) {
- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_PullBackupKey_, context, request, response, reactor);
+::grpc::ClientAsyncReaderWriter< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>* BackupService::Stub::PrepareAsyncRecoverBackupKeyRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>::Create(channel_.get(), cq, rpcmethod_RecoverBackupKey_, context, false, nullptr);
}
-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::PrepareAsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::backup::PullBackupKeyResponse, ::backup::PullBackupKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_PullBackupKey_, context, request);
+::grpc::ClientReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PullBackupRaw(::grpc::ClientContext* context) {
+ return ::grpc::internal::ClientReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), rpcmethod_PullBackup_, context);
}
-::grpc::ClientAsyncResponseReader< ::backup::PullBackupKeyResponse>* BackupService::Stub::AsyncPullBackupKeyRaw(::grpc::ClientContext* context, const ::backup::PullBackupKeyRequest& request, ::grpc::CompletionQueue* cq) {
- auto* result =
- this->PrepareAsyncPullBackupKeyRaw(context, request, cq);
- result->StartCall();
- return result;
+void BackupService::Stub::async::PullBackup(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::backup::PullBackupRequest,::backup::PullBackupResponse>* reactor) {
+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::backup::PullBackupRequest,::backup::PullBackupResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullBackup_, context, reactor);
}
-::grpc::ClientReader< ::backup::PullCompactionResponse>* BackupService::Stub::PullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request) {
- return ::grpc::internal::ClientReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), rpcmethod_PullCompaction_, context, request);
+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::AsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, true, tag);
}
-void BackupService::Stub::async::PullCompaction(::grpc::ClientContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ClientReadReactor< ::backup::PullCompactionResponse>* reactor) {
- ::grpc::internal::ClientCallbackReaderFactory< ::backup::PullCompactionResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_PullCompaction_, context, request, reactor);
-}
-
-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::AsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq, void* tag) {
- return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, true, tag);
-}
-
-::grpc::ClientAsyncReader< ::backup::PullCompactionResponse>* BackupService::Stub::PrepareAsyncPullCompactionRaw(::grpc::ClientContext* context, const ::backup::PullCompactionRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncReaderFactory< ::backup::PullCompactionResponse>::Create(channel_.get(), cq, rpcmethod_PullCompaction_, context, request, false, nullptr);
+::grpc::ClientAsyncReaderWriter< ::backup::PullBackupRequest, ::backup::PullBackupResponse>* BackupService::Stub::PrepareAsyncPullBackupRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::backup::PullBackupRequest, ::backup::PullBackupResponse>::Create(channel_.get(), cq, rpcmethod_PullBackup_, context, false, nullptr);
}
BackupService::Service::Service() {
AddMethod(new ::grpc::internal::RpcServiceMethod(
BackupService_method_names[0],
- ::grpc::internal::RpcMethod::CLIENT_STREAMING,
- new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::ResetKeyRequest, ::google::protobuf::Empty>(
+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::CreateNewBackupRequest, ::backup::CreateNewBackupResponse>(
[](BackupService::Service* service,
::grpc::ServerContext* ctx,
- ::grpc::ServerReader<::backup::ResetKeyRequest>* reader,
- ::google::protobuf::Empty* resp) {
- return service->ResetKey(ctx, reader, resp);
+ ::grpc::ServerReaderWriter<::backup::CreateNewBackupResponse,
+ ::backup::CreateNewBackupRequest>* stream) {
+ return service->CreateNewBackup(ctx, stream);
}, this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
BackupService_method_names[1],
- ::grpc::internal::RpcMethod::NORMAL_RPC,
- new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+ ::grpc::internal::RpcMethod::CLIENT_STREAMING,
+ new ::grpc::internal::ClientStreamingHandler< BackupService::Service, ::backup::SendLogRequest, ::google::protobuf::Empty>(
[](BackupService::Service* service,
::grpc::ServerContext* ctx,
- const ::backup::SendLogRequest* req,
+ ::grpc::ServerReader<::backup::SendLogRequest>* reader,
::google::protobuf::Empty* resp) {
- return service->SendLog(ctx, req, resp);
+ return service->SendLog(ctx, reader, resp);
}, this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
BackupService_method_names[2],
- ::grpc::internal::RpcMethod::NORMAL_RPC,
- new ::grpc::internal::RpcMethodHandler< BackupService::Service, ::backup::PullBackupKeyRequest, ::backup::PullBackupKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::RecoverBackupKeyRequest, ::backup::RecoverBackupKeyResponse>(
[](BackupService::Service* service,
::grpc::ServerContext* ctx,
- const ::backup::PullBackupKeyRequest* req,
- ::backup::PullBackupKeyResponse* resp) {
- return service->PullBackupKey(ctx, req, resp);
+ ::grpc::ServerReaderWriter<::backup::RecoverBackupKeyResponse,
+ ::backup::RecoverBackupKeyRequest>* stream) {
+ return service->RecoverBackupKey(ctx, stream);
}, this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
BackupService_method_names[3],
- ::grpc::internal::RpcMethod::SERVER_STREAMING,
- new ::grpc::internal::ServerStreamingHandler< BackupService::Service, ::backup::PullCompactionRequest, ::backup::PullCompactionResponse>(
+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
+ new ::grpc::internal::BidiStreamingHandler< BackupService::Service, ::backup::PullBackupRequest, ::backup::PullBackupResponse>(
[](BackupService::Service* service,
::grpc::ServerContext* ctx,
- const ::backup::PullCompactionRequest* req,
- ::grpc::ServerWriter<::backup::PullCompactionResponse>* writer) {
- return service->PullCompaction(ctx, req, writer);
+ ::grpc::ServerReaderWriter<::backup::PullBackupResponse,
+ ::backup::PullBackupRequest>* stream) {
+ return service->PullBackup(ctx, stream);
}, this)));
}
BackupService::Service::~Service() {
}
-::grpc::Status BackupService::Service::ResetKey(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::ResetKeyRequest>* reader, ::google::protobuf::Empty* response) {
+::grpc::Status BackupService::Service::CreateNewBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::CreateNewBackupResponse, ::backup::CreateNewBackupRequest>* stream) {
(void) context;
- (void) reader;
- (void) response;
+ (void) stream;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
-::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, const ::backup::SendLogRequest* request, ::google::protobuf::Empty* response) {
+::grpc::Status BackupService::Service::SendLog(::grpc::ServerContext* context, ::grpc::ServerReader< ::backup::SendLogRequest>* reader, ::google::protobuf::Empty* response) {
(void) context;
- (void) request;
+ (void) reader;
(void) response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
-::grpc::Status BackupService::Service::PullBackupKey(::grpc::ServerContext* context, const ::backup::PullBackupKeyRequest* request, ::backup::PullBackupKeyResponse* response) {
+::grpc::Status BackupService::Service::RecoverBackupKey(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::RecoverBackupKeyResponse, ::backup::RecoverBackupKeyRequest>* stream) {
(void) context;
- (void) request;
- (void) response;
+ (void) stream;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
-::grpc::Status BackupService::Service::PullCompaction(::grpc::ServerContext* context, const ::backup::PullCompactionRequest* request, ::grpc::ServerWriter< ::backup::PullCompactionResponse>* writer) {
+::grpc::Status BackupService::Service::PullBackup(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::backup::PullBackupResponse, ::backup::PullBackupRequest>* stream) {
(void) context;
- (void) request;
- (void) writer;
+ (void) stream;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.h
@@ -47,7 +47,7 @@
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
- static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[16]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -56,55 +56,95 @@
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 PullBackupKeyRequest;
-struct PullBackupKeyRequestDefaultTypeInternal;
-extern PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
-class PullBackupKeyResponse;
-struct PullBackupKeyResponseDefaultTypeInternal;
-extern PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
-class PullCompactionRequest;
-struct PullCompactionRequestDefaultTypeInternal;
-extern PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
-class PullCompactionResponse;
-struct PullCompactionResponseDefaultTypeInternal;
-extern PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
-class ResetKeyRequest;
-struct ResetKeyRequestDefaultTypeInternal;
-extern ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
+class BackupKeyEntropy;
+struct BackupKeyEntropyDefaultTypeInternal;
+extern BackupKeyEntropyDefaultTypeInternal _BackupKeyEntropy_default_instance_;
+class CreateNewBackupRequest;
+struct CreateNewBackupRequestDefaultTypeInternal;
+extern CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
+class CreateNewBackupResponse;
+struct CreateNewBackupResponseDefaultTypeInternal;
+extern CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
+class FullAuthenticationRequestData;
+struct FullAuthenticationRequestDataDefaultTypeInternal;
+extern FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
+class FullAuthenticationResponseData;
+struct FullAuthenticationResponseDataDefaultTypeInternal;
+extern FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
+class PakeAuthenticationRequestData;
+struct PakeAuthenticationRequestDataDefaultTypeInternal;
+extern PakeAuthenticationRequestDataDefaultTypeInternal _PakeAuthenticationRequestData_default_instance_;
+class PakeAuthenticationResponseData;
+struct PakeAuthenticationResponseDataDefaultTypeInternal;
+extern PakeAuthenticationResponseDataDefaultTypeInternal _PakeAuthenticationResponseData_default_instance_;
+class PakeRegistrationRequestAndUserID;
+struct PakeRegistrationRequestAndUserIDDefaultTypeInternal;
+extern PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
+class PullBackupRequest;
+struct PullBackupRequestDefaultTypeInternal;
+extern PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
+class PullBackupResponse;
+struct PullBackupResponseDefaultTypeInternal;
+extern PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
+class RecoverBackupKeyRequest;
+struct RecoverBackupKeyRequestDefaultTypeInternal;
+extern RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
+class RecoverBackupKeyResponse;
+struct RecoverBackupKeyResponseDefaultTypeInternal;
+extern RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
class SendLogRequest;
struct SendLogRequestDefaultTypeInternal;
extern SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
+class SimpleAuthenticationRequestData;
+struct SimpleAuthenticationRequestDataDefaultTypeInternal;
+extern SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
+class WalletAuthenticationRequestData;
+struct WalletAuthenticationRequestDataDefaultTypeInternal;
+extern WalletAuthenticationRequestDataDefaultTypeInternal _WalletAuthenticationRequestData_default_instance_;
+class WalletAuthenticationResponseData;
+struct WalletAuthenticationResponseDataDefaultTypeInternal;
+extern WalletAuthenticationResponseDataDefaultTypeInternal _WalletAuthenticationResponseData_default_instance_;
} // namespace backup
PROTOBUF_NAMESPACE_OPEN
-template<> ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage<::backup::PullBackupKeyRequest>(Arena*);
-template<> ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage<::backup::PullBackupKeyResponse>(Arena*);
-template<> ::backup::PullCompactionRequest* Arena::CreateMaybeMessage<::backup::PullCompactionRequest>(Arena*);
-template<> ::backup::PullCompactionResponse* Arena::CreateMaybeMessage<::backup::PullCompactionResponse>(Arena*);
-template<> ::backup::ResetKeyRequest* Arena::CreateMaybeMessage<::backup::ResetKeyRequest>(Arena*);
+template<> ::backup::BackupKeyEntropy* Arena::CreateMaybeMessage<::backup::BackupKeyEntropy>(Arena*);
+template<> ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage<::backup::CreateNewBackupRequest>(Arena*);
+template<> ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage<::backup::CreateNewBackupResponse>(Arena*);
+template<> ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::FullAuthenticationRequestData>(Arena*);
+template<> ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage<::backup::FullAuthenticationResponseData>(Arena*);
+template<> ::backup::PakeAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::PakeAuthenticationRequestData>(Arena*);
+template<> ::backup::PakeAuthenticationResponseData* Arena::CreateMaybeMessage<::backup::PakeAuthenticationResponseData>(Arena*);
+template<> ::backup::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage<::backup::PakeRegistrationRequestAndUserID>(Arena*);
+template<> ::backup::PullBackupRequest* Arena::CreateMaybeMessage<::backup::PullBackupRequest>(Arena*);
+template<> ::backup::PullBackupResponse* Arena::CreateMaybeMessage<::backup::PullBackupResponse>(Arena*);
+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::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(Arena*);
+template<> ::backup::WalletAuthenticationRequestData* Arena::CreateMaybeMessage<::backup::WalletAuthenticationRequestData>(Arena*);
+template<> ::backup::WalletAuthenticationResponseData* Arena::CreateMaybeMessage<::backup::WalletAuthenticationResponseData>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace backup {
// ===================================================================
-class ResetKeyRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.ResetKeyRequest) */ {
+class PakeRegistrationRequestAndUserID PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PakeRegistrationRequestAndUserID) */ {
public:
- inline ResetKeyRequest() : ResetKeyRequest(nullptr) {}
- virtual ~ResetKeyRequest();
- explicit constexpr ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline PakeRegistrationRequestAndUserID() : PakeRegistrationRequestAndUserID(nullptr) {}
+ virtual ~PakeRegistrationRequestAndUserID();
+ explicit constexpr PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- ResetKeyRequest(const ResetKeyRequest& from);
- ResetKeyRequest(ResetKeyRequest&& from) noexcept
- : ResetKeyRequest() {
+ PakeRegistrationRequestAndUserID(const PakeRegistrationRequestAndUserID& from);
+ PakeRegistrationRequestAndUserID(PakeRegistrationRequestAndUserID&& from) noexcept
+ : PakeRegistrationRequestAndUserID() {
*this = ::std::move(from);
}
- inline ResetKeyRequest& operator=(const ResetKeyRequest& from) {
+ inline PakeRegistrationRequestAndUserID& operator=(const PakeRegistrationRequestAndUserID& from) {
CopyFrom(from);
return *this;
}
- inline ResetKeyRequest& operator=(ResetKeyRequest&& from) noexcept {
+ inline PakeRegistrationRequestAndUserID& operator=(PakeRegistrationRequestAndUserID&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -122,26 +162,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const ResetKeyRequest& default_instance() {
+ static const PakeRegistrationRequestAndUserID& default_instance() {
return *internal_default_instance();
}
- enum DataCase {
- kNewKey = 2,
- kCompactionChunk = 3,
- DATA_NOT_SET = 0,
- };
-
- static inline const ResetKeyRequest* internal_default_instance() {
- return reinterpret_cast<const ResetKeyRequest*>(
- &_ResetKeyRequest_default_instance_);
+ static inline const PakeRegistrationRequestAndUserID* internal_default_instance() {
+ return reinterpret_cast<const PakeRegistrationRequestAndUserID*>(
+ &_PakeRegistrationRequestAndUserID_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
- friend void swap(ResetKeyRequest& a, ResetKeyRequest& b) {
+ friend void swap(PakeRegistrationRequestAndUserID& a, PakeRegistrationRequestAndUserID& b) {
a.Swap(&b);
}
- inline void Swap(ResetKeyRequest* other) {
+ inline void Swap(PakeRegistrationRequestAndUserID* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -149,7 +183,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(ResetKeyRequest* other) {
+ void UnsafeArenaSwap(PakeRegistrationRequestAndUserID* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -157,17 +191,17 @@
// implements Message ----------------------------------------------
- inline ResetKeyRequest* New() const final {
- return CreateMaybeMessage<ResetKeyRequest>(nullptr);
+ inline PakeRegistrationRequestAndUserID* New() const final {
+ return CreateMaybeMessage<PakeRegistrationRequestAndUserID>(nullptr);
}
- ResetKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<ResetKeyRequest>(arena);
+ PakeRegistrationRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PakeRegistrationRequestAndUserID>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const ResetKeyRequest& from);
- void MergeFrom(const ResetKeyRequest& from);
+ void CopyFrom(const PakeRegistrationRequestAndUserID& from);
+ void MergeFrom(const PakeRegistrationRequestAndUserID& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -181,13 +215,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(ResetKeyRequest* other);
+ void InternalSwap(PakeRegistrationRequestAndUserID* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.ResetKeyRequest";
+ return "backup.PakeRegistrationRequestAndUserID";
}
protected:
- explicit ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -206,11 +240,10 @@
// accessors -------------------------------------------------------
enum : int {
- kUserIdFieldNumber = 1,
- kNewKeyFieldNumber = 2,
- kCompactionChunkFieldNumber = 3,
+ kUserIDFieldNumber = 1,
+ kPakeRegistrationRequestFieldNumber = 2,
};
- // string userId = 1;
+ // string userID = 1;
void clear_userid();
const std::string& userid() const;
void set_userid(const std::string& value);
@@ -226,92 +259,54 @@
std::string* _internal_mutable_userid();
public:
- // bytes newKey = 2;
- bool has_newkey() const;
- private:
- bool _internal_has_newkey() const;
- public:
- void clear_newkey();
- const std::string& newkey() const;
- void set_newkey(const std::string& value);
- void set_newkey(std::string&& value);
- void set_newkey(const char* value);
- void set_newkey(const void* value, size_t size);
- std::string* mutable_newkey();
- std::string* release_newkey();
- void set_allocated_newkey(std::string* newkey);
- private:
- const std::string& _internal_newkey() const;
- void _internal_set_newkey(const std::string& value);
- std::string* _internal_mutable_newkey();
- public:
-
- // bytes compactionChunk = 3;
- bool has_compactionchunk() const;
- private:
- bool _internal_has_compactionchunk() const;
- public:
- void clear_compactionchunk();
- const std::string& compactionchunk() const;
- void set_compactionchunk(const std::string& value);
- void set_compactionchunk(std::string&& value);
- void set_compactionchunk(const char* value);
- void set_compactionchunk(const void* value, size_t size);
- std::string* mutable_compactionchunk();
- std::string* release_compactionchunk();
- void set_allocated_compactionchunk(std::string* compactionchunk);
+ // bytes pakeRegistrationRequest = 2;
+ void clear_pakeregistrationrequest();
+ const std::string& pakeregistrationrequest() const;
+ void set_pakeregistrationrequest(const std::string& value);
+ void set_pakeregistrationrequest(std::string&& value);
+ void set_pakeregistrationrequest(const char* value);
+ void set_pakeregistrationrequest(const void* value, size_t size);
+ std::string* mutable_pakeregistrationrequest();
+ std::string* release_pakeregistrationrequest();
+ void set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest);
private:
- const std::string& _internal_compactionchunk() const;
- void _internal_set_compactionchunk(const std::string& value);
- std::string* _internal_mutable_compactionchunk();
+ const std::string& _internal_pakeregistrationrequest() const;
+ void _internal_set_pakeregistrationrequest(const std::string& value);
+ std::string* _internal_mutable_pakeregistrationrequest();
public:
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(class_scope:backup.PakeRegistrationRequestAndUserID)
private:
class _Internal;
- void set_has_newkey();
- void set_has_compactionchunk();
-
- 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_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
- union DataUnion {
- constexpr DataUnion() : _constinit_{} {}
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newkey_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
- } data_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationrequest_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
friend struct ::TableStruct_backup_2eproto;
};
// -------------------------------------------------------------------
-class SendLogRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
+class PakeAuthenticationRequestData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PakeAuthenticationRequestData) */ {
public:
- inline SendLogRequest() : SendLogRequest(nullptr) {}
- virtual ~SendLogRequest();
- explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline PakeAuthenticationRequestData() : PakeAuthenticationRequestData(nullptr) {}
+ virtual ~PakeAuthenticationRequestData();
+ explicit constexpr PakeAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- SendLogRequest(const SendLogRequest& from);
- SendLogRequest(SendLogRequest&& from) noexcept
- : SendLogRequest() {
+ PakeAuthenticationRequestData(const PakeAuthenticationRequestData& from);
+ PakeAuthenticationRequestData(PakeAuthenticationRequestData&& from) noexcept
+ : PakeAuthenticationRequestData() {
*this = ::std::move(from);
}
- inline SendLogRequest& operator=(const SendLogRequest& from) {
+ inline PakeAuthenticationRequestData& operator=(const PakeAuthenticationRequestData& from) {
CopyFrom(from);
return *this;
}
- inline SendLogRequest& operator=(SendLogRequest&& from) noexcept {
+ inline PakeAuthenticationRequestData& operator=(PakeAuthenticationRequestData&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -329,20 +324,29 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const SendLogRequest& default_instance() {
+ static const PakeAuthenticationRequestData& default_instance() {
return *internal_default_instance();
}
- static inline const SendLogRequest* internal_default_instance() {
- return reinterpret_cast<const SendLogRequest*>(
- &_SendLogRequest_default_instance_);
+ enum DataCase {
+ kPakeRegistrationRequestAndUserID = 1,
+ kPakeRegistrationUpload = 2,
+ kPakeCredentialRequest = 3,
+ kPakeCredentialFinalization = 4,
+ kPakeClientMAC = 5,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const PakeAuthenticationRequestData* internal_default_instance() {
+ return reinterpret_cast<const PakeAuthenticationRequestData*>(
+ &_PakeAuthenticationRequestData_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
- friend void swap(SendLogRequest& a, SendLogRequest& b) {
+ friend void swap(PakeAuthenticationRequestData& a, PakeAuthenticationRequestData& b) {
a.Swap(&b);
}
- inline void Swap(SendLogRequest* other) {
+ inline void Swap(PakeAuthenticationRequestData* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -350,7 +354,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(SendLogRequest* other) {
+ void UnsafeArenaSwap(PakeAuthenticationRequestData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -358,17 +362,17 @@
// implements Message ----------------------------------------------
- inline SendLogRequest* New() const final {
- return CreateMaybeMessage<SendLogRequest>(nullptr);
+ inline PakeAuthenticationRequestData* New() const final {
+ return CreateMaybeMessage<PakeAuthenticationRequestData>(nullptr);
}
- SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<SendLogRequest>(arena);
+ PakeAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PakeAuthenticationRequestData>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const SendLogRequest& from);
- void MergeFrom(const SendLogRequest& from);
+ void CopyFrom(const PakeAuthenticationRequestData& from);
+ void MergeFrom(const PakeAuthenticationRequestData& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -382,13 +386,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(SendLogRequest* other);
+ void InternalSwap(PakeAuthenticationRequestData* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.SendLogRequest";
+ return "backup.PakeAuthenticationRequestData";
}
protected:
- explicit SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit PakeAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -407,73 +411,161 @@
// accessors -------------------------------------------------------
enum : int {
- kUserIdFieldNumber = 1,
- kDataFieldNumber = 2,
+ kPakeRegistrationRequestAndUserIDFieldNumber = 1,
+ kPakeRegistrationUploadFieldNumber = 2,
+ kPakeCredentialRequestFieldNumber = 3,
+ kPakeCredentialFinalizationFieldNumber = 4,
+ kPakeClientMACFieldNumber = 5,
};
- // string userId = 1;
- void clear_userid();
- const std::string& userid() const;
- void set_userid(const std::string& value);
- void set_userid(std::string&& value);
- void set_userid(const char* value);
- void set_userid(const char* value, size_t size);
- std::string* mutable_userid();
- std::string* release_userid();
- void set_allocated_userid(std::string* userid);
+ // .backup.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+ bool has_pakeregistrationrequestanduserid() const;
private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
+ bool _internal_has_pakeregistrationrequestanduserid() const;
public:
+ void clear_pakeregistrationrequestanduserid();
+ const ::backup::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid() const;
+ ::backup::PakeRegistrationRequestAndUserID* release_pakeregistrationrequestanduserid();
+ ::backup::PakeRegistrationRequestAndUserID* mutable_pakeregistrationrequestanduserid();
+ void set_allocated_pakeregistrationrequestanduserid(::backup::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
+ private:
+ const ::backup::PakeRegistrationRequestAndUserID& _internal_pakeregistrationrequestanduserid() const;
+ ::backup::PakeRegistrationRequestAndUserID* _internal_mutable_pakeregistrationrequestanduserid();
+ public:
+ void unsafe_arena_set_allocated_pakeregistrationrequestanduserid(
+ ::backup::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
+ ::backup::PakeRegistrationRequestAndUserID* unsafe_arena_release_pakeregistrationrequestanduserid();
- // bytes data = 2;
- void clear_data();
- const std::string& data() const;
- void set_data(const std::string& value);
- void set_data(std::string&& value);
- void set_data(const char* value);
- void set_data(const void* value, size_t size);
- std::string* mutable_data();
- std::string* release_data();
- void set_allocated_data(std::string* data);
+ // bytes pakeRegistrationUpload = 2;
+ bool has_pakeregistrationupload() const;
+ private:
+ bool _internal_has_pakeregistrationupload() const;
+ public:
+ void clear_pakeregistrationupload();
+ const std::string& pakeregistrationupload() const;
+ void set_pakeregistrationupload(const std::string& value);
+ void set_pakeregistrationupload(std::string&& value);
+ void set_pakeregistrationupload(const char* value);
+ void set_pakeregistrationupload(const void* value, size_t size);
+ std::string* mutable_pakeregistrationupload();
+ std::string* release_pakeregistrationupload();
+ void set_allocated_pakeregistrationupload(std::string* pakeregistrationupload);
private:
- const std::string& _internal_data() const;
- void _internal_set_data(const std::string& value);
- std::string* _internal_mutable_data();
+ const std::string& _internal_pakeregistrationupload() const;
+ void _internal_set_pakeregistrationupload(const std::string& value);
+ std::string* _internal_mutable_pakeregistrationupload();
public:
- // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
+ // bytes pakeCredentialRequest = 3;
+ bool has_pakecredentialrequest() const;
+ private:
+ bool _internal_has_pakecredentialrequest() const;
+ public:
+ void clear_pakecredentialrequest();
+ const std::string& pakecredentialrequest() const;
+ void set_pakecredentialrequest(const std::string& value);
+ void set_pakecredentialrequest(std::string&& value);
+ void set_pakecredentialrequest(const char* value);
+ void set_pakecredentialrequest(const void* value, size_t size);
+ std::string* mutable_pakecredentialrequest();
+ std::string* release_pakecredentialrequest();
+ void set_allocated_pakecredentialrequest(std::string* pakecredentialrequest);
+ private:
+ const std::string& _internal_pakecredentialrequest() const;
+ void _internal_set_pakecredentialrequest(const std::string& value);
+ std::string* _internal_mutable_pakecredentialrequest();
+ public:
+
+ // bytes pakeCredentialFinalization = 4;
+ bool has_pakecredentialfinalization() const;
+ private:
+ bool _internal_has_pakecredentialfinalization() const;
+ public:
+ void clear_pakecredentialfinalization();
+ const std::string& pakecredentialfinalization() const;
+ void set_pakecredentialfinalization(const std::string& value);
+ void set_pakecredentialfinalization(std::string&& value);
+ void set_pakecredentialfinalization(const char* value);
+ void set_pakecredentialfinalization(const void* value, size_t size);
+ std::string* mutable_pakecredentialfinalization();
+ std::string* release_pakecredentialfinalization();
+ void set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization);
+ private:
+ const std::string& _internal_pakecredentialfinalization() const;
+ void _internal_set_pakecredentialfinalization(const std::string& value);
+ std::string* _internal_mutable_pakecredentialfinalization();
+ public:
+
+ // bytes pakeClientMAC = 5;
+ bool has_pakeclientmac() const;
+ private:
+ bool _internal_has_pakeclientmac() const;
+ public:
+ void clear_pakeclientmac();
+ const std::string& pakeclientmac() const;
+ void set_pakeclientmac(const std::string& value);
+ void set_pakeclientmac(std::string&& value);
+ void set_pakeclientmac(const char* value);
+ void set_pakeclientmac(const void* value, size_t size);
+ std::string* mutable_pakeclientmac();
+ std::string* release_pakeclientmac();
+ void set_allocated_pakeclientmac(std::string* pakeclientmac);
+ private:
+ const std::string& _internal_pakeclientmac() const;
+ void _internal_set_pakeclientmac(const std::string& value);
+ std::string* _internal_mutable_pakeclientmac();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.PakeAuthenticationRequestData)
private:
class _Internal;
+ void set_has_pakeregistrationrequestanduserid();
+ void set_has_pakeregistrationupload();
+ void set_has_pakecredentialrequest();
+ void set_has_pakecredentialfinalization();
+ void set_has_pakeclientmac();
+
+ 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_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
+ union DataUnion {
+ constexpr DataUnion() : _constinit_{} {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+ ::backup::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationupload_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeclientmac_;
+ } data_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
friend struct ::TableStruct_backup_2eproto;
};
// -------------------------------------------------------------------
-class PullBackupKeyRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyRequest) */ {
+class WalletAuthenticationRequestData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.WalletAuthenticationRequestData) */ {
public:
- inline PullBackupKeyRequest() : PullBackupKeyRequest(nullptr) {}
- virtual ~PullBackupKeyRequest();
- explicit constexpr PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline WalletAuthenticationRequestData() : WalletAuthenticationRequestData(nullptr) {}
+ virtual ~WalletAuthenticationRequestData();
+ explicit constexpr WalletAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- PullBackupKeyRequest(const PullBackupKeyRequest& from);
- PullBackupKeyRequest(PullBackupKeyRequest&& from) noexcept
- : PullBackupKeyRequest() {
+ WalletAuthenticationRequestData(const WalletAuthenticationRequestData& from);
+ WalletAuthenticationRequestData(WalletAuthenticationRequestData&& from) noexcept
+ : WalletAuthenticationRequestData() {
*this = ::std::move(from);
}
- inline PullBackupKeyRequest& operator=(const PullBackupKeyRequest& from) {
+ inline WalletAuthenticationRequestData& operator=(const WalletAuthenticationRequestData& from) {
CopyFrom(from);
return *this;
}
- inline PullBackupKeyRequest& operator=(PullBackupKeyRequest&& from) noexcept {
+ inline WalletAuthenticationRequestData& operator=(WalletAuthenticationRequestData&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -491,20 +583,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const PullBackupKeyRequest& default_instance() {
+ static const WalletAuthenticationRequestData& default_instance() {
return *internal_default_instance();
}
- static inline const PullBackupKeyRequest* internal_default_instance() {
- return reinterpret_cast<const PullBackupKeyRequest*>(
- &_PullBackupKeyRequest_default_instance_);
+ static inline const WalletAuthenticationRequestData* internal_default_instance() {
+ return reinterpret_cast<const WalletAuthenticationRequestData*>(
+ &_WalletAuthenticationRequestData_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
- friend void swap(PullBackupKeyRequest& a, PullBackupKeyRequest& b) {
+ friend void swap(WalletAuthenticationRequestData& a, WalletAuthenticationRequestData& b) {
a.Swap(&b);
}
- inline void Swap(PullBackupKeyRequest* other) {
+ inline void Swap(WalletAuthenticationRequestData* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -512,7 +604,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(PullBackupKeyRequest* other) {
+ void UnsafeArenaSwap(WalletAuthenticationRequestData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -520,17 +612,17 @@
// implements Message ----------------------------------------------
- inline PullBackupKeyRequest* New() const final {
- return CreateMaybeMessage<PullBackupKeyRequest>(nullptr);
+ inline WalletAuthenticationRequestData* New() const final {
+ return CreateMaybeMessage<WalletAuthenticationRequestData>(nullptr);
}
- PullBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PullBackupKeyRequest>(arena);
+ WalletAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<WalletAuthenticationRequestData>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PullBackupKeyRequest& from);
- void MergeFrom(const PullBackupKeyRequest& from);
+ void CopyFrom(const WalletAuthenticationRequestData& from);
+ void MergeFrom(const WalletAuthenticationRequestData& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -544,13 +636,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(PullBackupKeyRequest* other);
+ void InternalSwap(WalletAuthenticationRequestData* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.PullBackupKeyRequest";
+ return "backup.WalletAuthenticationRequestData";
}
protected:
- explicit PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit WalletAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -569,10 +661,11 @@
// accessors -------------------------------------------------------
enum : int {
- kUserIdFieldNumber = 1,
- kPakeKeyFieldNumber = 2,
+ kUserIDFieldNumber = 1,
+ kWalletAddressFieldNumber = 2,
+ kSignedMessageFieldNumber = 3,
};
- // string userId = 1;
+ // string userID = 1;
void clear_userid();
const std::string& userid() const;
void set_userid(const std::string& value);
@@ -588,23 +681,39 @@
std::string* _internal_mutable_userid();
public:
- // bytes pakeKey = 2;
- void clear_pakekey();
- const std::string& pakekey() const;
- void set_pakekey(const std::string& value);
- void set_pakekey(std::string&& value);
- void set_pakekey(const char* value);
- void set_pakekey(const void* value, size_t size);
- std::string* mutable_pakekey();
- std::string* release_pakekey();
- void set_allocated_pakekey(std::string* pakekey);
+ // string walletAddress = 2;
+ void clear_walletaddress();
+ const std::string& walletaddress() const;
+ void set_walletaddress(const std::string& value);
+ void set_walletaddress(std::string&& value);
+ void set_walletaddress(const char* value);
+ void set_walletaddress(const char* value, size_t size);
+ std::string* mutable_walletaddress();
+ std::string* release_walletaddress();
+ void set_allocated_walletaddress(std::string* walletaddress);
+ private:
+ const std::string& _internal_walletaddress() const;
+ void _internal_set_walletaddress(const std::string& value);
+ std::string* _internal_mutable_walletaddress();
+ public:
+
+ // bytes signedMessage = 3;
+ void clear_signedmessage();
+ const std::string& signedmessage() const;
+ void set_signedmessage(const std::string& value);
+ void set_signedmessage(std::string&& value);
+ void set_signedmessage(const char* value);
+ void set_signedmessage(const void* value, size_t size);
+ std::string* mutable_signedmessage();
+ std::string* release_signedmessage();
+ void set_allocated_signedmessage(std::string* signedmessage);
private:
- const std::string& _internal_pakekey() const;
- void _internal_set_pakekey(const std::string& value);
- std::string* _internal_mutable_pakekey();
+ const std::string& _internal_signedmessage() const;
+ void _internal_set_signedmessage(const std::string& value);
+ std::string* _internal_mutable_signedmessage();
public:
- // @@protoc_insertion_point(class_scope:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(class_scope:backup.WalletAuthenticationRequestData)
private:
class _Internal;
@@ -612,30 +721,31 @@
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakekey_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr walletaddress_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signedmessage_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_backup_2eproto;
};
// -------------------------------------------------------------------
-class PullBackupKeyResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupKeyResponse) */ {
+class FullAuthenticationRequestData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationRequestData) */ {
public:
- inline PullBackupKeyResponse() : PullBackupKeyResponse(nullptr) {}
- virtual ~PullBackupKeyResponse();
- explicit constexpr PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline FullAuthenticationRequestData() : FullAuthenticationRequestData(nullptr) {}
+ virtual ~FullAuthenticationRequestData();
+ explicit constexpr FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- PullBackupKeyResponse(const PullBackupKeyResponse& from);
- PullBackupKeyResponse(PullBackupKeyResponse&& from) noexcept
- : PullBackupKeyResponse() {
+ FullAuthenticationRequestData(const FullAuthenticationRequestData& from);
+ FullAuthenticationRequestData(FullAuthenticationRequestData&& from) noexcept
+ : FullAuthenticationRequestData() {
*this = ::std::move(from);
}
- inline PullBackupKeyResponse& operator=(const PullBackupKeyResponse& from) {
+ inline FullAuthenticationRequestData& operator=(const FullAuthenticationRequestData& from) {
CopyFrom(from);
return *this;
}
- inline PullBackupKeyResponse& operator=(PullBackupKeyResponse&& from) noexcept {
+ inline FullAuthenticationRequestData& operator=(FullAuthenticationRequestData&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -653,20 +763,26 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const PullBackupKeyResponse& default_instance() {
+ static const FullAuthenticationRequestData& default_instance() {
return *internal_default_instance();
}
- static inline const PullBackupKeyResponse* internal_default_instance() {
- return reinterpret_cast<const PullBackupKeyResponse*>(
- &_PullBackupKeyResponse_default_instance_);
+ enum DataCase {
+ kPakeAuthenticationRequestData = 1,
+ kWalletAuthenticationRequestData = 2,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const FullAuthenticationRequestData* internal_default_instance() {
+ return reinterpret_cast<const FullAuthenticationRequestData*>(
+ &_FullAuthenticationRequestData_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
- friend void swap(PullBackupKeyResponse& a, PullBackupKeyResponse& b) {
+ friend void swap(FullAuthenticationRequestData& a, FullAuthenticationRequestData& b) {
a.Swap(&b);
}
- inline void Swap(PullBackupKeyResponse* other) {
+ inline void Swap(FullAuthenticationRequestData* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -674,7 +790,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(PullBackupKeyResponse* other) {
+ void UnsafeArenaSwap(FullAuthenticationRequestData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -682,17 +798,17 @@
// implements Message ----------------------------------------------
- inline PullBackupKeyResponse* New() const final {
- return CreateMaybeMessage<PullBackupKeyResponse>(nullptr);
+ inline FullAuthenticationRequestData* New() const final {
+ return CreateMaybeMessage<FullAuthenticationRequestData>(nullptr);
}
- PullBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PullBackupKeyResponse>(arena);
+ FullAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<FullAuthenticationRequestData>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PullBackupKeyResponse& from);
- void MergeFrom(const PullBackupKeyResponse& from);
+ void CopyFrom(const FullAuthenticationRequestData& from);
+ void MergeFrom(const FullAuthenticationRequestData& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -706,13 +822,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(PullBackupKeyResponse* other);
+ void InternalSwap(FullAuthenticationRequestData* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.PullBackupKeyResponse";
+ return "backup.FullAuthenticationRequestData";
}
protected:
- explicit PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -731,55 +847,90 @@
// accessors -------------------------------------------------------
enum : int {
- kEncryptedBackupKeyFieldNumber = 1,
+ kPakeAuthenticationRequestDataFieldNumber = 1,
+ kWalletAuthenticationRequestDataFieldNumber = 2,
};
- // bytes encryptedBackupKey = 1;
- void clear_encryptedbackupkey();
- const std::string& encryptedbackupkey() const;
- void set_encryptedbackupkey(const std::string& value);
- void set_encryptedbackupkey(std::string&& value);
- void set_encryptedbackupkey(const char* value);
- void set_encryptedbackupkey(const void* value, size_t size);
- std::string* mutable_encryptedbackupkey();
- std::string* release_encryptedbackupkey();
- void set_allocated_encryptedbackupkey(std::string* encryptedbackupkey);
- private:
- const std::string& _internal_encryptedbackupkey() const;
- void _internal_set_encryptedbackupkey(const std::string& value);
- std::string* _internal_mutable_encryptedbackupkey();
- public:
-
- // @@protoc_insertion_point(class_scope:backup.PullBackupKeyResponse)
+ // .backup.PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+ bool has_pakeauthenticationrequestdata() const;
+ private:
+ bool _internal_has_pakeauthenticationrequestdata() const;
+ public:
+ void clear_pakeauthenticationrequestdata();
+ const ::backup::PakeAuthenticationRequestData& pakeauthenticationrequestdata() const;
+ ::backup::PakeAuthenticationRequestData* release_pakeauthenticationrequestdata();
+ ::backup::PakeAuthenticationRequestData* mutable_pakeauthenticationrequestdata();
+ void set_allocated_pakeauthenticationrequestdata(::backup::PakeAuthenticationRequestData* pakeauthenticationrequestdata);
+ private:
+ const ::backup::PakeAuthenticationRequestData& _internal_pakeauthenticationrequestdata() const;
+ ::backup::PakeAuthenticationRequestData* _internal_mutable_pakeauthenticationrequestdata();
+ public:
+ void unsafe_arena_set_allocated_pakeauthenticationrequestdata(
+ ::backup::PakeAuthenticationRequestData* pakeauthenticationrequestdata);
+ ::backup::PakeAuthenticationRequestData* unsafe_arena_release_pakeauthenticationrequestdata();
+
+ // .backup.WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+ bool has_walletauthenticationrequestdata() const;
+ private:
+ bool _internal_has_walletauthenticationrequestdata() const;
+ public:
+ void clear_walletauthenticationrequestdata();
+ const ::backup::WalletAuthenticationRequestData& walletauthenticationrequestdata() const;
+ ::backup::WalletAuthenticationRequestData* release_walletauthenticationrequestdata();
+ ::backup::WalletAuthenticationRequestData* mutable_walletauthenticationrequestdata();
+ void set_allocated_walletauthenticationrequestdata(::backup::WalletAuthenticationRequestData* walletauthenticationrequestdata);
+ private:
+ const ::backup::WalletAuthenticationRequestData& _internal_walletauthenticationrequestdata() const;
+ ::backup::WalletAuthenticationRequestData* _internal_mutable_walletauthenticationrequestdata();
+ public:
+ void unsafe_arena_set_allocated_walletauthenticationrequestdata(
+ ::backup::WalletAuthenticationRequestData* walletauthenticationrequestdata);
+ ::backup::WalletAuthenticationRequestData* unsafe_arena_release_walletauthenticationrequestdata();
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.FullAuthenticationRequestData)
private:
class _Internal;
+ void set_has_pakeauthenticationrequestdata();
+ void set_has_walletauthenticationrequestdata();
+
+ 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_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryptedbackupkey_;
+ union DataUnion {
+ constexpr DataUnion() : _constinit_{} {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+ ::backup::PakeAuthenticationRequestData* pakeauthenticationrequestdata_;
+ ::backup::WalletAuthenticationRequestData* walletauthenticationrequestdata_;
+ } data_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
friend struct ::TableStruct_backup_2eproto;
};
// -------------------------------------------------------------------
-class PullCompactionRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionRequest) */ {
+class WalletAuthenticationResponseData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.WalletAuthenticationResponseData) */ {
public:
- inline PullCompactionRequest() : PullCompactionRequest(nullptr) {}
- virtual ~PullCompactionRequest();
- explicit constexpr PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline WalletAuthenticationResponseData() : WalletAuthenticationResponseData(nullptr) {}
+ virtual ~WalletAuthenticationResponseData();
+ explicit constexpr WalletAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- PullCompactionRequest(const PullCompactionRequest& from);
- PullCompactionRequest(PullCompactionRequest&& from) noexcept
- : PullCompactionRequest() {
+ WalletAuthenticationResponseData(const WalletAuthenticationResponseData& from);
+ WalletAuthenticationResponseData(WalletAuthenticationResponseData&& from) noexcept
+ : WalletAuthenticationResponseData() {
*this = ::std::move(from);
}
- inline PullCompactionRequest& operator=(const PullCompactionRequest& from) {
+ inline WalletAuthenticationResponseData& operator=(const WalletAuthenticationResponseData& from) {
CopyFrom(from);
return *this;
}
- inline PullCompactionRequest& operator=(PullCompactionRequest&& from) noexcept {
+ inline WalletAuthenticationResponseData& operator=(WalletAuthenticationResponseData&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -797,20 +948,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const PullCompactionRequest& default_instance() {
+ static const WalletAuthenticationResponseData& default_instance() {
return *internal_default_instance();
}
- static inline const PullCompactionRequest* internal_default_instance() {
- return reinterpret_cast<const PullCompactionRequest*>(
- &_PullCompactionRequest_default_instance_);
+ static inline const WalletAuthenticationResponseData* internal_default_instance() {
+ return reinterpret_cast<const WalletAuthenticationResponseData*>(
+ &_WalletAuthenticationResponseData_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
- friend void swap(PullCompactionRequest& a, PullCompactionRequest& b) {
+ friend void swap(WalletAuthenticationResponseData& a, WalletAuthenticationResponseData& b) {
a.Swap(&b);
}
- inline void Swap(PullCompactionRequest* other) {
+ inline void Swap(WalletAuthenticationResponseData* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -818,7 +969,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(PullCompactionRequest* other) {
+ void UnsafeArenaSwap(WalletAuthenticationResponseData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -826,17 +977,17 @@
// implements Message ----------------------------------------------
- inline PullCompactionRequest* New() const final {
- return CreateMaybeMessage<PullCompactionRequest>(nullptr);
+ inline WalletAuthenticationResponseData* New() const final {
+ return CreateMaybeMessage<WalletAuthenticationResponseData>(nullptr);
}
- PullCompactionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PullCompactionRequest>(arena);
+ WalletAuthenticationResponseData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<WalletAuthenticationResponseData>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PullCompactionRequest& from);
- void MergeFrom(const PullCompactionRequest& from);
+ void CopyFrom(const WalletAuthenticationResponseData& from);
+ void MergeFrom(const WalletAuthenticationResponseData& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -850,13 +1001,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(PullCompactionRequest* other);
+ void InternalSwap(WalletAuthenticationResponseData* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.PullCompactionRequest";
+ return "backup.WalletAuthenticationResponseData";
}
protected:
- explicit PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit WalletAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -875,73 +1026,48 @@
// accessors -------------------------------------------------------
enum : int {
- kUserIdFieldNumber = 1,
- kMessageFieldNumber = 2,
+ kSuccessFieldNumber = 1,
};
- // string userId = 1;
- void clear_userid();
- const std::string& userid() const;
- void set_userid(const std::string& value);
- void set_userid(std::string&& value);
- void set_userid(const char* value);
- void set_userid(const char* value, size_t size);
- std::string* mutable_userid();
- std::string* release_userid();
- void set_allocated_userid(std::string* userid);
- private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
- public:
-
- // bytes message = 2;
- void clear_message();
- const std::string& message() const;
- void set_message(const std::string& value);
- void set_message(std::string&& value);
- void set_message(const char* value);
- void set_message(const void* value, size_t size);
- std::string* mutable_message();
- std::string* release_message();
- void set_allocated_message(std::string* message);
+ // bool success = 1;
+ void clear_success();
+ bool success() const;
+ void set_success(bool value);
private:
- const std::string& _internal_message() const;
- void _internal_set_message(const std::string& value);
- std::string* _internal_mutable_message();
+ bool _internal_success() const;
+ void _internal_set_success(bool value);
public:
- // @@protoc_insertion_point(class_scope:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(class_scope:backup.WalletAuthenticationResponseData)
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 message_;
+ bool success_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_backup_2eproto;
};
// -------------------------------------------------------------------
-class PullCompactionResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullCompactionResponse) */ {
+class PakeAuthenticationResponseData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PakeAuthenticationResponseData) */ {
public:
- inline PullCompactionResponse() : PullCompactionResponse(nullptr) {}
- virtual ~PullCompactionResponse();
- explicit constexpr PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline PakeAuthenticationResponseData() : PakeAuthenticationResponseData(nullptr) {}
+ virtual ~PakeAuthenticationResponseData();
+ explicit constexpr PakeAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- PullCompactionResponse(const PullCompactionResponse& from);
- PullCompactionResponse(PullCompactionResponse&& from) noexcept
- : PullCompactionResponse() {
+ PakeAuthenticationResponseData(const PakeAuthenticationResponseData& from);
+ PakeAuthenticationResponseData(PakeAuthenticationResponseData&& from) noexcept
+ : PakeAuthenticationResponseData() {
*this = ::std::move(from);
}
- inline PullCompactionResponse& operator=(const PullCompactionResponse& from) {
+ inline PakeAuthenticationResponseData& operator=(const PakeAuthenticationResponseData& from) {
CopyFrom(from);
return *this;
}
- inline PullCompactionResponse& operator=(PullCompactionResponse&& from) noexcept {
+ inline PakeAuthenticationResponseData& operator=(PakeAuthenticationResponseData&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -959,26 +1085,28 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const PullCompactionResponse& default_instance() {
+ static const PakeAuthenticationResponseData& default_instance() {
return *internal_default_instance();
}
enum DataCase {
- kCompactionChunk = 1,
- kLogChunk = 2,
+ kPakeRegistrationResponse = 1,
+ kPakeRegistrationSuccess = 2,
+ kPakeCredentialResponse = 3,
+ kPakeServerMAC = 4,
DATA_NOT_SET = 0,
};
- static inline const PullCompactionResponse* internal_default_instance() {
- return reinterpret_cast<const PullCompactionResponse*>(
- &_PullCompactionResponse_default_instance_);
+ static inline const PakeAuthenticationResponseData* internal_default_instance() {
+ return reinterpret_cast<const PakeAuthenticationResponseData*>(
+ &_PakeAuthenticationResponseData_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
- friend void swap(PullCompactionResponse& a, PullCompactionResponse& b) {
+ friend void swap(PakeAuthenticationResponseData& a, PakeAuthenticationResponseData& b) {
a.Swap(&b);
}
- inline void Swap(PullCompactionResponse* other) {
+ inline void Swap(PakeAuthenticationResponseData* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -986,7 +1114,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(PullCompactionResponse* other) {
+ void UnsafeArenaSwap(PakeAuthenticationResponseData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -994,17 +1122,17 @@
// implements Message ----------------------------------------------
- inline PullCompactionResponse* New() const final {
- return CreateMaybeMessage<PullCompactionResponse>(nullptr);
+ inline PakeAuthenticationResponseData* New() const final {
+ return CreateMaybeMessage<PakeAuthenticationResponseData>(nullptr);
}
- PullCompactionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PullCompactionResponse>(arena);
+ PakeAuthenticationResponseData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PakeAuthenticationResponseData>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PullCompactionResponse& from);
- void MergeFrom(const PullCompactionResponse& from);
+ void CopyFrom(const PakeAuthenticationResponseData& from);
+ void MergeFrom(const PakeAuthenticationResponseData& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -1018,13 +1146,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(PullCompactionResponse* other);
+ void InternalSwap(PakeAuthenticationResponseData* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "backup.PullCompactionResponse";
+ return "backup.PakeAuthenticationResponseData";
}
protected:
- explicit PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit PakeAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1043,56 +1171,93 @@
// accessors -------------------------------------------------------
enum : int {
- kCompactionChunkFieldNumber = 1,
- kLogChunkFieldNumber = 2,
+ kPakeRegistrationResponseFieldNumber = 1,
+ kPakeRegistrationSuccessFieldNumber = 2,
+ kPakeCredentialResponseFieldNumber = 3,
+ kPakeServerMACFieldNumber = 4,
};
- // bytes compactionChunk = 1;
- bool has_compactionchunk() const;
+ // bytes pakeRegistrationResponse = 1;
+ bool has_pakeregistrationresponse() const;
private:
- bool _internal_has_compactionchunk() const;
+ bool _internal_has_pakeregistrationresponse() const;
public:
- void clear_compactionchunk();
- const std::string& compactionchunk() const;
- void set_compactionchunk(const std::string& value);
- void set_compactionchunk(std::string&& value);
- void set_compactionchunk(const char* value);
- void set_compactionchunk(const void* value, size_t size);
- std::string* mutable_compactionchunk();
- std::string* release_compactionchunk();
- void set_allocated_compactionchunk(std::string* compactionchunk);
+ void clear_pakeregistrationresponse();
+ const std::string& pakeregistrationresponse() const;
+ void set_pakeregistrationresponse(const std::string& value);
+ void set_pakeregistrationresponse(std::string&& value);
+ void set_pakeregistrationresponse(const char* value);
+ void set_pakeregistrationresponse(const void* value, size_t size);
+ std::string* mutable_pakeregistrationresponse();
+ std::string* release_pakeregistrationresponse();
+ void set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse);
private:
- const std::string& _internal_compactionchunk() const;
- void _internal_set_compactionchunk(const std::string& value);
- std::string* _internal_mutable_compactionchunk();
+ const std::string& _internal_pakeregistrationresponse() const;
+ void _internal_set_pakeregistrationresponse(const std::string& value);
+ std::string* _internal_mutable_pakeregistrationresponse();
public:
- // bytes logChunk = 2;
- bool has_logchunk() const;
+ // bool pakeRegistrationSuccess = 2;
+ bool has_pakeregistrationsuccess() const;
private:
- bool _internal_has_logchunk() const;
+ bool _internal_has_pakeregistrationsuccess() const;
public:
- void clear_logchunk();
- const std::string& logchunk() const;
- void set_logchunk(const std::string& value);
- void set_logchunk(std::string&& value);
- void set_logchunk(const char* value);
- void set_logchunk(const void* value, size_t size);
- std::string* mutable_logchunk();
- std::string* release_logchunk();
- void set_allocated_logchunk(std::string* logchunk);
+ void clear_pakeregistrationsuccess();
+ bool pakeregistrationsuccess() const;
+ void set_pakeregistrationsuccess(bool value);
private:
- const std::string& _internal_logchunk() const;
- void _internal_set_logchunk(const std::string& value);
- std::string* _internal_mutable_logchunk();
+ bool _internal_pakeregistrationsuccess() const;
+ void _internal_set_pakeregistrationsuccess(bool value);
+ public:
+
+ // bytes pakeCredentialResponse = 3;
+ bool has_pakecredentialresponse() const;
+ private:
+ bool _internal_has_pakecredentialresponse() const;
+ public:
+ void clear_pakecredentialresponse();
+ const std::string& pakecredentialresponse() const;
+ void set_pakecredentialresponse(const std::string& value);
+ void set_pakecredentialresponse(std::string&& value);
+ void set_pakecredentialresponse(const char* value);
+ void set_pakecredentialresponse(const void* value, size_t size);
+ std::string* mutable_pakecredentialresponse();
+ std::string* release_pakecredentialresponse();
+ void set_allocated_pakecredentialresponse(std::string* pakecredentialresponse);
+ private:
+ const std::string& _internal_pakecredentialresponse() const;
+ void _internal_set_pakecredentialresponse(const std::string& value);
+ std::string* _internal_mutable_pakecredentialresponse();
+ public:
+
+ // bytes pakeServerMAC = 4;
+ bool has_pakeservermac() const;
+ private:
+ bool _internal_has_pakeservermac() const;
+ public:
+ void clear_pakeservermac();
+ const std::string& pakeservermac() const;
+ void set_pakeservermac(const std::string& value);
+ void set_pakeservermac(std::string&& value);
+ void set_pakeservermac(const char* value);
+ void set_pakeservermac(const void* value, size_t size);
+ std::string* mutable_pakeservermac();
+ std::string* release_pakeservermac();
+ void set_allocated_pakeservermac(std::string* pakeservermac);
+ private:
+ const std::string& _internal_pakeservermac() const;
+ void _internal_set_pakeservermac(const std::string& value);
+ std::string* _internal_mutable_pakeservermac();
public:
void clear_data();
DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(class_scope:backup.PakeAuthenticationResponseData)
private:
class _Internal;
- void set_has_compactionchunk();
- void set_has_logchunk();
+ void set_has_pakeregistrationresponse();
+ void set_has_pakeregistrationsuccess();
+ void set_has_pakecredentialresponse();
+ void set_has_pakeservermac();
inline bool has_data() const;
inline void clear_has_data();
@@ -1103,797 +1268,4880 @@
union DataUnion {
constexpr DataUnion() : _constinit_{} {}
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationresponse_;
+ bool pakeregistrationsuccess_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialresponse_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeservermac_;
} data_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
friend struct ::TableStruct_backup_2eproto;
};
-// ===================================================================
-
-
-// ===================================================================
+// -------------------------------------------------------------------
-#ifdef __GNUC__
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif // __GNUC__
-// ResetKeyRequest
+class FullAuthenticationResponseData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.FullAuthenticationResponseData) */ {
+ public:
+ inline FullAuthenticationResponseData() : FullAuthenticationResponseData(nullptr) {}
+ virtual ~FullAuthenticationResponseData();
+ explicit constexpr FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-// string userId = 1;
-inline void ResetKeyRequest::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& ResetKeyRequest::userid() const {
- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.userId)
- return _internal_userid();
-}
-inline void ResetKeyRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.userId)
-}
-inline std::string* ResetKeyRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.userId)
- return _internal_mutable_userid();
-}
-inline const std::string& ResetKeyRequest::_internal_userid() const {
- return userid_.Get();
-}
-inline void ResetKeyRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void ResetKeyRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.userId)
-}
-inline void ResetKeyRequest::set_userid(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.userId)
-}
-inline void ResetKeyRequest::set_userid(const char* value,
- size_t size) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.userId)
-}
-inline std::string* ResetKeyRequest::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* ResetKeyRequest::release_userid() {
- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.userId)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void ResetKeyRequest::set_allocated_userid(std::string* userid) {
- if (userid != nullptr) {
-
- } else {
-
+ FullAuthenticationResponseData(const FullAuthenticationResponseData& from);
+ FullAuthenticationResponseData(FullAuthenticationResponseData&& from) noexcept
+ : FullAuthenticationResponseData() {
+ *this = ::std::move(from);
}
- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.userId)
-}
-// bytes newKey = 2;
-inline bool ResetKeyRequest::_internal_has_newkey() const {
- return data_case() == kNewKey;
-}
-inline bool ResetKeyRequest::has_newkey() const {
- return _internal_has_newkey();
-}
-inline void ResetKeyRequest::set_has_newkey() {
- _oneof_case_[0] = kNewKey;
+ inline FullAuthenticationResponseData& operator=(const FullAuthenticationResponseData& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline FullAuthenticationResponseData& operator=(FullAuthenticationResponseData&& 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 FullAuthenticationResponseData& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kPakeAuthenticationResponseData = 1,
+ kWalletAuthenticationResponseData = 2,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const FullAuthenticationResponseData* internal_default_instance() {
+ return reinterpret_cast<const FullAuthenticationResponseData*>(
+ &_FullAuthenticationResponseData_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 6;
+
+ friend void swap(FullAuthenticationResponseData& a, FullAuthenticationResponseData& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(FullAuthenticationResponseData* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(FullAuthenticationResponseData* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline FullAuthenticationResponseData* New() const final {
+ return CreateMaybeMessage<FullAuthenticationResponseData>(nullptr);
+ }
+
+ FullAuthenticationResponseData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<FullAuthenticationResponseData>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const FullAuthenticationResponseData& from);
+ void MergeFrom(const FullAuthenticationResponseData& 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(FullAuthenticationResponseData* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.FullAuthenticationResponseData";
+ }
+ protected:
+ explicit FullAuthenticationResponseData(::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 {
+ kPakeAuthenticationResponseDataFieldNumber = 1,
+ kWalletAuthenticationResponseDataFieldNumber = 2,
+ };
+ // .backup.PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+ bool has_pakeauthenticationresponsedata() const;
+ private:
+ bool _internal_has_pakeauthenticationresponsedata() const;
+ public:
+ void clear_pakeauthenticationresponsedata();
+ const ::backup::PakeAuthenticationResponseData& pakeauthenticationresponsedata() const;
+ ::backup::PakeAuthenticationResponseData* release_pakeauthenticationresponsedata();
+ ::backup::PakeAuthenticationResponseData* mutable_pakeauthenticationresponsedata();
+ void set_allocated_pakeauthenticationresponsedata(::backup::PakeAuthenticationResponseData* pakeauthenticationresponsedata);
+ private:
+ const ::backup::PakeAuthenticationResponseData& _internal_pakeauthenticationresponsedata() const;
+ ::backup::PakeAuthenticationResponseData* _internal_mutable_pakeauthenticationresponsedata();
+ public:
+ void unsafe_arena_set_allocated_pakeauthenticationresponsedata(
+ ::backup::PakeAuthenticationResponseData* pakeauthenticationresponsedata);
+ ::backup::PakeAuthenticationResponseData* unsafe_arena_release_pakeauthenticationresponsedata();
+
+ // .backup.WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+ bool has_walletauthenticationresponsedata() const;
+ private:
+ bool _internal_has_walletauthenticationresponsedata() const;
+ public:
+ void clear_walletauthenticationresponsedata();
+ const ::backup::WalletAuthenticationResponseData& walletauthenticationresponsedata() const;
+ ::backup::WalletAuthenticationResponseData* release_walletauthenticationresponsedata();
+ ::backup::WalletAuthenticationResponseData* mutable_walletauthenticationresponsedata();
+ void set_allocated_walletauthenticationresponsedata(::backup::WalletAuthenticationResponseData* walletauthenticationresponsedata);
+ private:
+ const ::backup::WalletAuthenticationResponseData& _internal_walletauthenticationresponsedata() const;
+ ::backup::WalletAuthenticationResponseData* _internal_mutable_walletauthenticationresponsedata();
+ public:
+ void unsafe_arena_set_allocated_walletauthenticationresponsedata(
+ ::backup::WalletAuthenticationResponseData* walletauthenticationresponsedata);
+ ::backup::WalletAuthenticationResponseData* unsafe_arena_release_walletauthenticationresponsedata();
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.FullAuthenticationResponseData)
+ private:
+ class _Internal;
+ void set_has_pakeauthenticationresponsedata();
+ void set_has_walletauthenticationresponsedata();
+
+ 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::PakeAuthenticationResponseData* pakeauthenticationresponsedata_;
+ ::backup::WalletAuthenticationResponseData* walletauthenticationresponsedata_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SimpleAuthenticationRequestData PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SimpleAuthenticationRequestData) */ {
+ public:
+ inline SimpleAuthenticationRequestData() : SimpleAuthenticationRequestData(nullptr) {}
+ virtual ~SimpleAuthenticationRequestData();
+ explicit constexpr SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from);
+ SimpleAuthenticationRequestData(SimpleAuthenticationRequestData&& from) noexcept
+ : SimpleAuthenticationRequestData() {
+ *this = ::std::move(from);
+ }
+
+ inline SimpleAuthenticationRequestData& operator=(const SimpleAuthenticationRequestData& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline SimpleAuthenticationRequestData& operator=(SimpleAuthenticationRequestData&& 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 SimpleAuthenticationRequestData& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const SimpleAuthenticationRequestData* internal_default_instance() {
+ return reinterpret_cast<const SimpleAuthenticationRequestData*>(
+ &_SimpleAuthenticationRequestData_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 7;
+
+ friend void swap(SimpleAuthenticationRequestData& a, SimpleAuthenticationRequestData& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(SimpleAuthenticationRequestData* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(SimpleAuthenticationRequestData* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline SimpleAuthenticationRequestData* New() const final {
+ return CreateMaybeMessage<SimpleAuthenticationRequestData>(nullptr);
+ }
+
+ SimpleAuthenticationRequestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<SimpleAuthenticationRequestData>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const SimpleAuthenticationRequestData& from);
+ void MergeFrom(const SimpleAuthenticationRequestData& 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(SimpleAuthenticationRequestData* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.SimpleAuthenticationRequestData";
+ }
+ protected:
+ explicit SimpleAuthenticationRequestData(::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 {
+ kBackupIDFieldNumber = 1,
+ kUserIDFieldNumber = 2,
+ };
+ // string backupID = 1;
+ void clear_backupid();
+ const std::string& backupid() const;
+ void set_backupid(const std::string& value);
+ void set_backupid(std::string&& value);
+ void set_backupid(const char* value);
+ void set_backupid(const char* value, size_t size);
+ std::string* mutable_backupid();
+ std::string* release_backupid();
+ void set_allocated_backupid(std::string* backupid);
+ private:
+ const std::string& _internal_backupid() const;
+ void _internal_set_backupid(const std::string& value);
+ std::string* _internal_mutable_backupid();
+ public:
+
+ // string userID = 2;
+ void clear_userid();
+ const std::string& userid() const;
+ void set_userid(const std::string& value);
+ 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:
+
+ // @@protoc_insertion_point(class_scope:backup.SimpleAuthenticationRequestData)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BackupKeyEntropy PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.BackupKeyEntropy) */ {
+ public:
+ inline BackupKeyEntropy() : BackupKeyEntropy(nullptr) {}
+ virtual ~BackupKeyEntropy();
+ explicit constexpr BackupKeyEntropy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ BackupKeyEntropy(const BackupKeyEntropy& from);
+ BackupKeyEntropy(BackupKeyEntropy&& from) noexcept
+ : BackupKeyEntropy() {
+ *this = ::std::move(from);
+ }
+
+ inline BackupKeyEntropy& operator=(const BackupKeyEntropy& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline BackupKeyEntropy& operator=(BackupKeyEntropy&& 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 BackupKeyEntropy& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kNonce = 1,
+ kRawMessage = 2,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const BackupKeyEntropy* internal_default_instance() {
+ return reinterpret_cast<const BackupKeyEntropy*>(
+ &_BackupKeyEntropy_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(BackupKeyEntropy& a, BackupKeyEntropy& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(BackupKeyEntropy* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(BackupKeyEntropy* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline BackupKeyEntropy* New() const final {
+ return CreateMaybeMessage<BackupKeyEntropy>(nullptr);
+ }
+
+ BackupKeyEntropy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<BackupKeyEntropy>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const BackupKeyEntropy& from);
+ void MergeFrom(const BackupKeyEntropy& 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(BackupKeyEntropy* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.BackupKeyEntropy";
+ }
+ protected:
+ explicit BackupKeyEntropy(::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 {
+ kNonceFieldNumber = 1,
+ kRawMessageFieldNumber = 2,
+ };
+ // bytes nonce = 1;
+ bool has_nonce() const;
+ private:
+ bool _internal_has_nonce() const;
+ public:
+ void clear_nonce();
+ const std::string& nonce() const;
+ void set_nonce(const std::string& value);
+ void set_nonce(std::string&& value);
+ void set_nonce(const char* value);
+ void set_nonce(const void* value, size_t size);
+ std::string* mutable_nonce();
+ std::string* release_nonce();
+ void set_allocated_nonce(std::string* nonce);
+ private:
+ const std::string& _internal_nonce() const;
+ void _internal_set_nonce(const std::string& value);
+ std::string* _internal_mutable_nonce();
+ public:
+
+ // bytes rawMessage = 2;
+ bool has_rawmessage() const;
+ private:
+ bool _internal_has_rawmessage() const;
+ public:
+ void clear_rawmessage();
+ const std::string& rawmessage() const;
+ void set_rawmessage(const std::string& value);
+ void set_rawmessage(std::string&& value);
+ void set_rawmessage(const char* value);
+ void set_rawmessage(const void* value, size_t size);
+ std::string* mutable_rawmessage();
+ std::string* release_rawmessage();
+ void set_allocated_rawmessage(std::string* rawmessage);
+ private:
+ const std::string& _internal_rawmessage() const;
+ void _internal_set_rawmessage(const std::string& value);
+ std::string* _internal_mutable_rawmessage();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.BackupKeyEntropy)
+ private:
+ class _Internal;
+ void set_has_nonce();
+ void set_has_rawmessage();
+
+ 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_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rawmessage_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CreateNewBackupRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupRequest) */ {
+ public:
+ inline CreateNewBackupRequest() : CreateNewBackupRequest(nullptr) {}
+ virtual ~CreateNewBackupRequest();
+ explicit constexpr CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ CreateNewBackupRequest(const CreateNewBackupRequest& from);
+ CreateNewBackupRequest(CreateNewBackupRequest&& from) noexcept
+ : CreateNewBackupRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline CreateNewBackupRequest& operator=(const CreateNewBackupRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline CreateNewBackupRequest& operator=(CreateNewBackupRequest&& 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 CreateNewBackupRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kAuthenticationRequestData = 1,
+ kBackupKeyEntropy = 2,
+ kNewCompactionChunk = 3,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const CreateNewBackupRequest* internal_default_instance() {
+ return reinterpret_cast<const CreateNewBackupRequest*>(
+ &_CreateNewBackupRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 9;
+
+ friend void swap(CreateNewBackupRequest& a, CreateNewBackupRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(CreateNewBackupRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(CreateNewBackupRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline CreateNewBackupRequest* New() const final {
+ return CreateMaybeMessage<CreateNewBackupRequest>(nullptr);
+ }
+
+ CreateNewBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<CreateNewBackupRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const CreateNewBackupRequest& from);
+ void MergeFrom(const CreateNewBackupRequest& 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(CreateNewBackupRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.CreateNewBackupRequest";
+ }
+ protected:
+ explicit CreateNewBackupRequest(::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 {
+ kAuthenticationRequestDataFieldNumber = 1,
+ kBackupKeyEntropyFieldNumber = 2,
+ kNewCompactionChunkFieldNumber = 3,
+ };
+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+ bool has_authenticationrequestdata() const;
+ private:
+ bool _internal_has_authenticationrequestdata() const;
+ public:
+ void clear_authenticationrequestdata();
+ const ::backup::FullAuthenticationRequestData& authenticationrequestdata() const;
+ ::backup::FullAuthenticationRequestData* release_authenticationrequestdata();
+ ::backup::FullAuthenticationRequestData* mutable_authenticationrequestdata();
+ void set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata);
+ private:
+ const ::backup::FullAuthenticationRequestData& _internal_authenticationrequestdata() const;
+ ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationrequestdata();
+ public:
+ void unsafe_arena_set_allocated_authenticationrequestdata(
+ ::backup::FullAuthenticationRequestData* authenticationrequestdata);
+ ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationrequestdata();
+
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ bool has_backupkeyentropy() const;
+ private:
+ bool _internal_has_backupkeyentropy() const;
+ public:
+ void clear_backupkeyentropy();
+ const ::backup::BackupKeyEntropy& backupkeyentropy() const;
+ ::backup::BackupKeyEntropy* release_backupkeyentropy();
+ ::backup::BackupKeyEntropy* mutable_backupkeyentropy();
+ void set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy);
+ private:
+ const ::backup::BackupKeyEntropy& _internal_backupkeyentropy() const;
+ ::backup::BackupKeyEntropy* _internal_mutable_backupkeyentropy();
+ public:
+ void unsafe_arena_set_allocated_backupkeyentropy(
+ ::backup::BackupKeyEntropy* backupkeyentropy);
+ ::backup::BackupKeyEntropy* unsafe_arena_release_backupkeyentropy();
+
+ // bytes newCompactionChunk = 3;
+ bool has_newcompactionchunk() const;
+ private:
+ bool _internal_has_newcompactionchunk() const;
+ public:
+ void clear_newcompactionchunk();
+ const std::string& newcompactionchunk() const;
+ void set_newcompactionchunk(const std::string& value);
+ void set_newcompactionchunk(std::string&& value);
+ void set_newcompactionchunk(const char* value);
+ void set_newcompactionchunk(const void* value, size_t size);
+ std::string* mutable_newcompactionchunk();
+ std::string* release_newcompactionchunk();
+ void set_allocated_newcompactionchunk(std::string* newcompactionchunk);
+ private:
+ const std::string& _internal_newcompactionchunk() const;
+ void _internal_set_newcompactionchunk(const std::string& value);
+ std::string* _internal_mutable_newcompactionchunk();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.CreateNewBackupRequest)
+ private:
+ class _Internal;
+ void set_has_authenticationrequestdata();
+ void set_has_backupkeyentropy();
+ void set_has_newcompactionchunk();
+
+ 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::FullAuthenticationRequestData* authenticationrequestdata_;
+ ::backup::BackupKeyEntropy* backupkeyentropy_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newcompactionchunk_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class CreateNewBackupResponse PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.CreateNewBackupResponse) */ {
+ public:
+ inline CreateNewBackupResponse() : CreateNewBackupResponse(nullptr) {}
+ virtual ~CreateNewBackupResponse();
+ explicit constexpr CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ CreateNewBackupResponse(const CreateNewBackupResponse& from);
+ CreateNewBackupResponse(CreateNewBackupResponse&& from) noexcept
+ : CreateNewBackupResponse() {
+ *this = ::std::move(from);
+ }
+
+ inline CreateNewBackupResponse& operator=(const CreateNewBackupResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline CreateNewBackupResponse& operator=(CreateNewBackupResponse&& from) noexcept {
+ if (GetArena() == from.GetArena()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const CreateNewBackupResponse& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kAuthenticationResponseData = 1,
+ kEntropyValid = 2,
+ kBackupID = 3,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const CreateNewBackupResponse* internal_default_instance() {
+ return reinterpret_cast<const CreateNewBackupResponse*>(
+ &_CreateNewBackupResponse_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 10;
+
+ friend void swap(CreateNewBackupResponse& a, CreateNewBackupResponse& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(CreateNewBackupResponse* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(CreateNewBackupResponse* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline CreateNewBackupResponse* New() const final {
+ return CreateMaybeMessage<CreateNewBackupResponse>(nullptr);
+ }
+
+ CreateNewBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<CreateNewBackupResponse>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const CreateNewBackupResponse& from);
+ void MergeFrom(const CreateNewBackupResponse& from);
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ inline void SharedCtor();
+ inline void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(CreateNewBackupResponse* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.CreateNewBackupResponse";
+ }
+ protected:
+ explicit CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kAuthenticationResponseDataFieldNumber = 1,
+ kEntropyValidFieldNumber = 2,
+ kBackupIDFieldNumber = 3,
+ };
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ bool has_authenticationresponsedata() const;
+ private:
+ bool _internal_has_authenticationresponsedata() const;
+ public:
+ void clear_authenticationresponsedata();
+ const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
+ ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
+ ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
+ void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
+ private:
+ const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
+ ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
+ public:
+ void unsafe_arena_set_allocated_authenticationresponsedata(
+ ::backup::FullAuthenticationResponseData* authenticationresponsedata);
+ ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();
+
+ // bool entropyValid = 2;
+ bool has_entropyvalid() const;
+ private:
+ bool _internal_has_entropyvalid() const;
+ public:
+ void clear_entropyvalid();
+ bool entropyvalid() const;
+ void set_entropyvalid(bool value);
+ private:
+ bool _internal_entropyvalid() const;
+ void _internal_set_entropyvalid(bool value);
+ public:
+
+ // string backupID = 3;
+ bool has_backupid() const;
+ private:
+ bool _internal_has_backupid() const;
+ public:
+ void clear_backupid();
+ const std::string& backupid() const;
+ void set_backupid(const std::string& value);
+ void set_backupid(std::string&& value);
+ void set_backupid(const char* value);
+ void set_backupid(const char* value, size_t size);
+ std::string* mutable_backupid();
+ std::string* release_backupid();
+ void set_allocated_backupid(std::string* backupid);
+ private:
+ const std::string& _internal_backupid() const;
+ void _internal_set_backupid(const std::string& value);
+ std::string* _internal_mutable_backupid();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.CreateNewBackupResponse)
+ private:
+ class _Internal;
+ void set_has_authenticationresponsedata();
+ void set_has_entropyvalid();
+ void set_has_backupid();
+
+ 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::FullAuthenticationResponseData* authenticationresponsedata_;
+ bool entropyvalid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SendLogRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.SendLogRequest) */ {
+ public:
+ inline SendLogRequest() : SendLogRequest(nullptr) {}
+ virtual ~SendLogRequest();
+ explicit constexpr SendLogRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ SendLogRequest(const SendLogRequest& from);
+ SendLogRequest(SendLogRequest&& from) noexcept
+ : SendLogRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline SendLogRequest& operator=(const SendLogRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline SendLogRequest& operator=(SendLogRequest&& 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 SendLogRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const SendLogRequest* internal_default_instance() {
+ return reinterpret_cast<const SendLogRequest*>(
+ &_SendLogRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 11;
+
+ friend void swap(SendLogRequest& a, SendLogRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(SendLogRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(SendLogRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline SendLogRequest* New() const final {
+ return CreateMaybeMessage<SendLogRequest>(nullptr);
+ }
+
+ SendLogRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<SendLogRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const SendLogRequest& from);
+ void MergeFrom(const SendLogRequest& from);
+ 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(SendLogRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.SendLogRequest";
+ }
+ protected:
+ explicit SendLogRequest(::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 {
+ kLogDataFieldNumber = 2,
+ kAuthenticationDataFieldNumber = 1,
+ };
+ // bytes logData = 2;
+ void clear_logdata();
+ const std::string& logdata() const;
+ void set_logdata(const std::string& value);
+ void set_logdata(std::string&& value);
+ void set_logdata(const char* value);
+ void set_logdata(const void* value, size_t size);
+ std::string* mutable_logdata();
+ std::string* release_logdata();
+ void set_allocated_logdata(std::string* logdata);
+ private:
+ const std::string& _internal_logdata() const;
+ void _internal_set_logdata(const std::string& value);
+ std::string* _internal_mutable_logdata();
+ public:
+
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ bool has_authenticationdata() const;
+ private:
+ bool _internal_has_authenticationdata() const;
+ public:
+ void clear_authenticationdata();
+ const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
+ ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
+ ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
+ void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
+ private:
+ const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
+ ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
+ public:
+ void unsafe_arena_set_allocated_authenticationdata(
+ ::backup::SimpleAuthenticationRequestData* authenticationdata);
+ ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+ // @@protoc_insertion_point(class_scope:backup.SendLogRequest)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logdata_;
+ ::backup::SimpleAuthenticationRequestData* authenticationdata_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecoverBackupKeyRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyRequest) */ {
+ public:
+ inline RecoverBackupKeyRequest() : RecoverBackupKeyRequest(nullptr) {}
+ virtual ~RecoverBackupKeyRequest();
+ explicit constexpr RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from);
+ RecoverBackupKeyRequest(RecoverBackupKeyRequest&& from) noexcept
+ : RecoverBackupKeyRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline RecoverBackupKeyRequest& operator=(const RecoverBackupKeyRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline RecoverBackupKeyRequest& operator=(RecoverBackupKeyRequest&& 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 RecoverBackupKeyRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const RecoverBackupKeyRequest* internal_default_instance() {
+ return reinterpret_cast<const RecoverBackupKeyRequest*>(
+ &_RecoverBackupKeyRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 12;
+
+ friend void swap(RecoverBackupKeyRequest& a, RecoverBackupKeyRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(RecoverBackupKeyRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(RecoverBackupKeyRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline RecoverBackupKeyRequest* New() const final {
+ return CreateMaybeMessage<RecoverBackupKeyRequest>(nullptr);
+ }
+
+ RecoverBackupKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<RecoverBackupKeyRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const RecoverBackupKeyRequest& from);
+ void MergeFrom(const RecoverBackupKeyRequest& 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(RecoverBackupKeyRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.RecoverBackupKeyRequest";
+ }
+ protected:
+ explicit RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kAuthenticationDataFieldNumber = 1,
+ };
+ // .backup.FullAuthenticationRequestData authenticationData = 1;
+ bool has_authenticationdata() const;
+ private:
+ bool _internal_has_authenticationdata() const;
+ public:
+ void clear_authenticationdata();
+ const ::backup::FullAuthenticationRequestData& authenticationdata() const;
+ ::backup::FullAuthenticationRequestData* release_authenticationdata();
+ ::backup::FullAuthenticationRequestData* mutable_authenticationdata();
+ void set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata);
+ private:
+ const ::backup::FullAuthenticationRequestData& _internal_authenticationdata() const;
+ ::backup::FullAuthenticationRequestData* _internal_mutable_authenticationdata();
+ public:
+ void unsafe_arena_set_allocated_authenticationdata(
+ ::backup::FullAuthenticationRequestData* authenticationdata);
+ ::backup::FullAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+ // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyRequest)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::backup::FullAuthenticationRequestData* authenticationdata_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RecoverBackupKeyResponse PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.RecoverBackupKeyResponse) */ {
+ public:
+ inline RecoverBackupKeyResponse() : RecoverBackupKeyResponse(nullptr) {}
+ virtual ~RecoverBackupKeyResponse();
+ explicit constexpr RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from);
+ RecoverBackupKeyResponse(RecoverBackupKeyResponse&& from) noexcept
+ : RecoverBackupKeyResponse() {
+ *this = ::std::move(from);
+ }
+
+ inline RecoverBackupKeyResponse& operator=(const RecoverBackupKeyResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline RecoverBackupKeyResponse& operator=(RecoverBackupKeyResponse&& 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 RecoverBackupKeyResponse& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kAuthenticationResponseData = 1,
+ kBackupKeyEntropy = 2,
+ kBackupID = 4,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const RecoverBackupKeyResponse* internal_default_instance() {
+ return reinterpret_cast<const RecoverBackupKeyResponse*>(
+ &_RecoverBackupKeyResponse_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 13;
+
+ friend void swap(RecoverBackupKeyResponse& a, RecoverBackupKeyResponse& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(RecoverBackupKeyResponse* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(RecoverBackupKeyResponse* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline RecoverBackupKeyResponse* New() const final {
+ return CreateMaybeMessage<RecoverBackupKeyResponse>(nullptr);
+ }
+
+ RecoverBackupKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<RecoverBackupKeyResponse>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const RecoverBackupKeyResponse& from);
+ void MergeFrom(const RecoverBackupKeyResponse& 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(RecoverBackupKeyResponse* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.RecoverBackupKeyResponse";
+ }
+ protected:
+ explicit RecoverBackupKeyResponse(::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 {
+ kAuthenticationResponseDataFieldNumber = 1,
+ kBackupKeyEntropyFieldNumber = 2,
+ kBackupIDFieldNumber = 4,
+ };
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ bool has_authenticationresponsedata() const;
+ private:
+ bool _internal_has_authenticationresponsedata() const;
+ public:
+ void clear_authenticationresponsedata();
+ const ::backup::FullAuthenticationResponseData& authenticationresponsedata() const;
+ ::backup::FullAuthenticationResponseData* release_authenticationresponsedata();
+ ::backup::FullAuthenticationResponseData* mutable_authenticationresponsedata();
+ void set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata);
+ private:
+ const ::backup::FullAuthenticationResponseData& _internal_authenticationresponsedata() const;
+ ::backup::FullAuthenticationResponseData* _internal_mutable_authenticationresponsedata();
+ public:
+ void unsafe_arena_set_allocated_authenticationresponsedata(
+ ::backup::FullAuthenticationResponseData* authenticationresponsedata);
+ ::backup::FullAuthenticationResponseData* unsafe_arena_release_authenticationresponsedata();
+
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ bool has_backupkeyentropy() const;
+ private:
+ bool _internal_has_backupkeyentropy() const;
+ public:
+ void clear_backupkeyentropy();
+ const ::backup::BackupKeyEntropy& backupkeyentropy() const;
+ ::backup::BackupKeyEntropy* release_backupkeyentropy();
+ ::backup::BackupKeyEntropy* mutable_backupkeyentropy();
+ void set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy);
+ private:
+ const ::backup::BackupKeyEntropy& _internal_backupkeyentropy() const;
+ ::backup::BackupKeyEntropy* _internal_mutable_backupkeyentropy();
+ public:
+ void unsafe_arena_set_allocated_backupkeyentropy(
+ ::backup::BackupKeyEntropy* backupkeyentropy);
+ ::backup::BackupKeyEntropy* unsafe_arena_release_backupkeyentropy();
+
+ // string backupID = 4;
+ bool has_backupid() const;
+ private:
+ bool _internal_has_backupid() const;
+ public:
+ void clear_backupid();
+ const std::string& backupid() const;
+ void set_backupid(const std::string& value);
+ void set_backupid(std::string&& value);
+ void set_backupid(const char* value);
+ void set_backupid(const char* value, size_t size);
+ std::string* mutable_backupid();
+ std::string* release_backupid();
+ void set_allocated_backupid(std::string* backupid);
+ private:
+ const std::string& _internal_backupid() const;
+ void _internal_set_backupid(const std::string& value);
+ std::string* _internal_mutable_backupid();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.RecoverBackupKeyResponse)
+ private:
+ class _Internal;
+ void set_has_authenticationresponsedata();
+ void set_has_backupkeyentropy();
+ void set_has_backupid();
+
+ 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::FullAuthenticationResponseData* authenticationresponsedata_;
+ ::backup::BackupKeyEntropy* backupkeyentropy_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backupid_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PullBackupRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupRequest) */ {
+ public:
+ inline PullBackupRequest() : PullBackupRequest(nullptr) {}
+ virtual ~PullBackupRequest();
+ explicit constexpr PullBackupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ PullBackupRequest(const PullBackupRequest& from);
+ PullBackupRequest(PullBackupRequest&& from) noexcept
+ : PullBackupRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline PullBackupRequest& operator=(const PullBackupRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline PullBackupRequest& operator=(PullBackupRequest&& 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 PullBackupRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const PullBackupRequest* internal_default_instance() {
+ return reinterpret_cast<const PullBackupRequest*>(
+ &_PullBackupRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 14;
+
+ friend void swap(PullBackupRequest& a, PullBackupRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(PullBackupRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(PullBackupRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline PullBackupRequest* New() const final {
+ return CreateMaybeMessage<PullBackupRequest>(nullptr);
+ }
+
+ PullBackupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PullBackupRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const PullBackupRequest& from);
+ void MergeFrom(const PullBackupRequest& 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(PullBackupRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.PullBackupRequest";
+ }
+ protected:
+ explicit PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+ private:
+ static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+ return ::descriptor_table_backup_2eproto_metadata_getter(kIndexInFileMessages);
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kAuthenticationDataFieldNumber = 1,
+ };
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ bool has_authenticationdata() const;
+ private:
+ bool _internal_has_authenticationdata() const;
+ public:
+ void clear_authenticationdata();
+ const ::backup::SimpleAuthenticationRequestData& authenticationdata() const;
+ ::backup::SimpleAuthenticationRequestData* release_authenticationdata();
+ ::backup::SimpleAuthenticationRequestData* mutable_authenticationdata();
+ void set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata);
+ private:
+ const ::backup::SimpleAuthenticationRequestData& _internal_authenticationdata() const;
+ ::backup::SimpleAuthenticationRequestData* _internal_mutable_authenticationdata();
+ public:
+ void unsafe_arena_set_allocated_authenticationdata(
+ ::backup::SimpleAuthenticationRequestData* authenticationdata);
+ ::backup::SimpleAuthenticationRequestData* unsafe_arena_release_authenticationdata();
+
+ // @@protoc_insertion_point(class_scope:backup.PullBackupRequest)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::backup::SimpleAuthenticationRequestData* authenticationdata_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_backup_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PullBackupResponse PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:backup.PullBackupResponse) */ {
+ public:
+ inline PullBackupResponse() : PullBackupResponse(nullptr) {}
+ virtual ~PullBackupResponse();
+ explicit constexpr PullBackupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ PullBackupResponse(const PullBackupResponse& from);
+ PullBackupResponse(PullBackupResponse&& from) noexcept
+ : PullBackupResponse() {
+ *this = ::std::move(from);
+ }
+
+ inline PullBackupResponse& operator=(const PullBackupResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline PullBackupResponse& operator=(PullBackupResponse&& 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 PullBackupResponse& default_instance() {
+ return *internal_default_instance();
+ }
+ enum DataCase {
+ kCompactionChunk = 1,
+ kLogChunk = 2,
+ DATA_NOT_SET = 0,
+ };
+
+ static inline const PullBackupResponse* internal_default_instance() {
+ return reinterpret_cast<const PullBackupResponse*>(
+ &_PullBackupResponse_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 15;
+
+ friend void swap(PullBackupResponse& a, PullBackupResponse& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(PullBackupResponse* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(PullBackupResponse* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline PullBackupResponse* New() const final {
+ return CreateMaybeMessage<PullBackupResponse>(nullptr);
+ }
+
+ PullBackupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PullBackupResponse>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const PullBackupResponse& from);
+ void MergeFrom(const PullBackupResponse& 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(PullBackupResponse* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "backup.PullBackupResponse";
+ }
+ protected:
+ explicit PullBackupResponse(::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 {
+ kCompactionChunkFieldNumber = 1,
+ kLogChunkFieldNumber = 2,
+ };
+ // bytes compactionChunk = 1;
+ bool has_compactionchunk() const;
+ private:
+ bool _internal_has_compactionchunk() const;
+ public:
+ void clear_compactionchunk();
+ const std::string& compactionchunk() const;
+ void set_compactionchunk(const std::string& value);
+ void set_compactionchunk(std::string&& value);
+ void set_compactionchunk(const char* value);
+ void set_compactionchunk(const void* value, size_t size);
+ std::string* mutable_compactionchunk();
+ std::string* release_compactionchunk();
+ void set_allocated_compactionchunk(std::string* compactionchunk);
+ private:
+ const std::string& _internal_compactionchunk() const;
+ void _internal_set_compactionchunk(const std::string& value);
+ std::string* _internal_mutable_compactionchunk();
+ public:
+
+ // bytes logChunk = 2;
+ bool has_logchunk() const;
+ private:
+ bool _internal_has_logchunk() const;
+ public:
+ void clear_logchunk();
+ const std::string& logchunk() const;
+ void set_logchunk(const std::string& value);
+ void set_logchunk(std::string&& value);
+ void set_logchunk(const char* value);
+ void set_logchunk(const void* value, size_t size);
+ std::string* mutable_logchunk();
+ std::string* release_logchunk();
+ void set_allocated_logchunk(std::string* logchunk);
+ private:
+ const std::string& _internal_logchunk() const;
+ void _internal_set_logchunk(const std::string& value);
+ std::string* _internal_mutable_logchunk();
+ public:
+
+ void clear_data();
+ DataCase data_case() const;
+ // @@protoc_insertion_point(class_scope:backup.PullBackupResponse)
+ private:
+ class _Internal;
+ void set_has_compactionchunk();
+ void set_has_logchunk();
+
+ 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_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compactionchunk_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr logchunk_;
+ } data_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+ friend struct ::TableStruct_backup_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// PakeRegistrationRequestAndUserID
+
+// string userID = 1;
+inline void PakeRegistrationRequestAndUserID::clear_userid() {
+ userid_.ClearToEmpty();
+}
+inline const std::string& PakeRegistrationRequestAndUserID::userid() const {
+ // @@protoc_insertion_point(field_get:backup.PakeRegistrationRequestAndUserID.userID)
+ return _internal_userid();
+}
+inline void PakeRegistrationRequestAndUserID::set_userid(const std::string& value) {
+ _internal_set_userid(value);
+ // @@protoc_insertion_point(field_set:backup.PakeRegistrationRequestAndUserID.userID)
+}
+inline std::string* PakeRegistrationRequestAndUserID::mutable_userid() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeRegistrationRequestAndUserID.userID)
+ return _internal_mutable_userid();
+}
+inline const std::string& PakeRegistrationRequestAndUserID::_internal_userid() const {
+ return userid_.Get();
+}
+inline void PakeRegistrationRequestAndUserID::_internal_set_userid(const std::string& value) {
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeRegistrationRequestAndUserID::set_userid(std::string&& value) {
+
+ userid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeRegistrationRequestAndUserID.userID)
+}
+inline void PakeRegistrationRequestAndUserID::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.PakeRegistrationRequestAndUserID.userID)
+}
+inline void PakeRegistrationRequestAndUserID::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.PakeRegistrationRequestAndUserID.userID)
+}
+inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_userid() {
+
+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeRegistrationRequestAndUserID::release_userid() {
+ // @@protoc_insertion_point(field_release:backup.PakeRegistrationRequestAndUserID.userID)
+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void PakeRegistrationRequestAndUserID::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.PakeRegistrationRequestAndUserID.userID)
+}
+
+// bytes pakeRegistrationRequest = 2;
+inline void PakeRegistrationRequestAndUserID::clear_pakeregistrationrequest() {
+ pakeregistrationrequest_.ClearToEmpty();
+}
+inline const std::string& PakeRegistrationRequestAndUserID::pakeregistrationrequest() const {
+ // @@protoc_insertion_point(field_get:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+ return _internal_pakeregistrationrequest();
+}
+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const std::string& value) {
+ _internal_set_pakeregistrationrequest(value);
+ // @@protoc_insertion_point(field_set:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+}
+inline std::string* PakeRegistrationRequestAndUserID::mutable_pakeregistrationrequest() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+ return _internal_mutable_pakeregistrationrequest();
+}
+inline const std::string& PakeRegistrationRequestAndUserID::_internal_pakeregistrationrequest() const {
+ return pakeregistrationrequest_.Get();
+}
+inline void PakeRegistrationRequestAndUserID::_internal_set_pakeregistrationrequest(const std::string& value) {
+
+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(std::string&& value) {
+
+ pakeregistrationrequest_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+}
+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+}
+inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const void* value,
+ size_t size) {
+
+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+}
+inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_pakeregistrationrequest() {
+
+ return pakeregistrationrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeRegistrationRequestAndUserID::release_pakeregistrationrequest() {
+ // @@protoc_insertion_point(field_release:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+ return pakeregistrationrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void PakeRegistrationRequestAndUserID::set_allocated_pakeregistrationrequest(std::string* pakeregistrationrequest) {
+ if (pakeregistrationrequest != nullptr) {
+
+ } else {
+
+ }
+ pakeregistrationrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakeregistrationrequest,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
+}
+
+// -------------------------------------------------------------------
+
+// PakeAuthenticationRequestData
+
+// .backup.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+inline bool PakeAuthenticationRequestData::_internal_has_pakeregistrationrequestanduserid() const {
+ return data_case() == kPakeRegistrationRequestAndUserID;
+}
+inline bool PakeAuthenticationRequestData::has_pakeregistrationrequestanduserid() const {
+ return _internal_has_pakeregistrationrequestanduserid();
+}
+inline void PakeAuthenticationRequestData::set_has_pakeregistrationrequestanduserid() {
+ _oneof_case_[0] = kPakeRegistrationRequestAndUserID;
+}
+inline void PakeAuthenticationRequestData::clear_pakeregistrationrequestanduserid() {
+ if (_internal_has_pakeregistrationrequestanduserid()) {
+ if (GetArena() == nullptr) {
+ delete data_.pakeregistrationrequestanduserid_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::PakeRegistrationRequestAndUserID* PakeAuthenticationRequestData::release_pakeregistrationrequestanduserid() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+ if (_internal_has_pakeregistrationrequestanduserid()) {
+ clear_has_data();
+ ::backup::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.pakeregistrationrequestanduserid_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::PakeRegistrationRequestAndUserID& PakeAuthenticationRequestData::_internal_pakeregistrationrequestanduserid() const {
+ return _internal_has_pakeregistrationrequestanduserid()
+ ? *data_.pakeregistrationrequestanduserid_
+ : reinterpret_cast< ::backup::PakeRegistrationRequestAndUserID&>(::backup::_PakeRegistrationRequestAndUserID_default_instance_);
+}
+inline const ::backup::PakeRegistrationRequestAndUserID& PakeAuthenticationRequestData::pakeregistrationrequestanduserid() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+ return _internal_pakeregistrationrequestanduserid();
+}
+inline ::backup::PakeRegistrationRequestAndUserID* PakeAuthenticationRequestData::unsafe_arena_release_pakeregistrationrequestanduserid() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+ if (_internal_has_pakeregistrationrequestanduserid()) {
+ clear_has_data();
+ ::backup::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
+ data_.pakeregistrationrequestanduserid_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationRequestData::unsafe_arena_set_allocated_pakeregistrationrequestanduserid(::backup::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid) {
+ clear_data();
+ if (pakeregistrationrequestanduserid) {
+ set_has_pakeregistrationrequestanduserid();
+ data_.pakeregistrationrequestanduserid_ = pakeregistrationrequestanduserid;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+}
+inline ::backup::PakeRegistrationRequestAndUserID* PakeAuthenticationRequestData::_internal_mutable_pakeregistrationrequestanduserid() {
+ if (!_internal_has_pakeregistrationrequestanduserid()) {
+ clear_data();
+ set_has_pakeregistrationrequestanduserid();
+ data_.pakeregistrationrequestanduserid_ = CreateMaybeMessage< ::backup::PakeRegistrationRequestAndUserID >(GetArena());
+ }
+ return data_.pakeregistrationrequestanduserid_;
+}
+inline ::backup::PakeRegistrationRequestAndUserID* PakeAuthenticationRequestData::mutable_pakeregistrationrequestanduserid() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+ return _internal_mutable_pakeregistrationrequestanduserid();
+}
+
+// bytes pakeRegistrationUpload = 2;
+inline bool PakeAuthenticationRequestData::_internal_has_pakeregistrationupload() const {
+ return data_case() == kPakeRegistrationUpload;
+}
+inline bool PakeAuthenticationRequestData::has_pakeregistrationupload() const {
+ return _internal_has_pakeregistrationupload();
+}
+inline void PakeAuthenticationRequestData::set_has_pakeregistrationupload() {
+ _oneof_case_[0] = kPakeRegistrationUpload;
+}
+inline void PakeAuthenticationRequestData::clear_pakeregistrationupload() {
+ if (_internal_has_pakeregistrationupload()) {
+ data_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationRequestData::pakeregistrationupload() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+ return _internal_pakeregistrationupload();
+}
+inline void PakeAuthenticationRequestData::set_pakeregistrationupload(const std::string& value) {
+ _internal_set_pakeregistrationupload(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline std::string* PakeAuthenticationRequestData::mutable_pakeregistrationupload() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+ return _internal_mutable_pakeregistrationupload();
+}
+inline const std::string& PakeAuthenticationRequestData::_internal_pakeregistrationupload() const {
+ if (_internal_has_pakeregistrationupload()) {
+ return data_.pakeregistrationupload_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationRequestData::_internal_set_pakeregistrationupload(const std::string& value) {
+ if (!_internal_has_pakeregistrationupload()) {
+ clear_data();
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationRequestData::set_pakeregistrationupload(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+ if (!_internal_has_pakeregistrationupload()) {
+ clear_data();
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationupload_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline void PakeAuthenticationRequestData::set_pakeregistrationupload(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakeregistrationupload()) {
+ clear_data();
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline void PakeAuthenticationRequestData::set_pakeregistrationupload(const void* value,
+ size_t size) {
+ if (!_internal_has_pakeregistrationupload()) {
+ clear_data();
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationupload_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+}
+inline std::string* PakeAuthenticationRequestData::_internal_mutable_pakeregistrationupload() {
+ if (!_internal_has_pakeregistrationupload()) {
+ clear_data();
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakeregistrationupload_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationRequestData::release_pakeregistrationupload() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+ if (_internal_has_pakeregistrationupload()) {
+ clear_has_data();
+ return data_.pakeregistrationupload_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationRequestData::set_allocated_pakeregistrationupload(std::string* pakeregistrationupload) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakeregistrationupload != nullptr) {
+ set_has_pakeregistrationupload();
+ data_.pakeregistrationupload_.UnsafeSetDefault(pakeregistrationupload);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakeregistrationupload);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationRequestData.pakeRegistrationUpload)
+}
+
+// bytes pakeCredentialRequest = 3;
+inline bool PakeAuthenticationRequestData::_internal_has_pakecredentialrequest() const {
+ return data_case() == kPakeCredentialRequest;
+}
+inline bool PakeAuthenticationRequestData::has_pakecredentialrequest() const {
+ return _internal_has_pakecredentialrequest();
+}
+inline void PakeAuthenticationRequestData::set_has_pakecredentialrequest() {
+ _oneof_case_[0] = kPakeCredentialRequest;
+}
+inline void PakeAuthenticationRequestData::clear_pakecredentialrequest() {
+ if (_internal_has_pakecredentialrequest()) {
+ data_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationRequestData::pakecredentialrequest() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+ return _internal_pakecredentialrequest();
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialrequest(const std::string& value) {
+ _internal_set_pakecredentialrequest(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+}
+inline std::string* PakeAuthenticationRequestData::mutable_pakecredentialrequest() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+ return _internal_mutable_pakecredentialrequest();
+}
+inline const std::string& PakeAuthenticationRequestData::_internal_pakecredentialrequest() const {
+ if (_internal_has_pakecredentialrequest()) {
+ return data_.pakecredentialrequest_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationRequestData::_internal_set_pakecredentialrequest(const std::string& value) {
+ if (!_internal_has_pakecredentialrequest()) {
+ clear_data();
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialrequest(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+ if (!_internal_has_pakecredentialrequest()) {
+ clear_data();
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialrequest_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialrequest(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakecredentialrequest()) {
+ clear_data();
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialrequest(const void* value,
+ size_t size) {
+ if (!_internal_has_pakecredentialrequest()) {
+ clear_data();
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialrequest_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+}
+inline std::string* PakeAuthenticationRequestData::_internal_mutable_pakecredentialrequest() {
+ if (!_internal_has_pakecredentialrequest()) {
+ clear_data();
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakecredentialrequest_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationRequestData::release_pakecredentialrequest() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+ if (_internal_has_pakecredentialrequest()) {
+ clear_has_data();
+ return data_.pakecredentialrequest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationRequestData::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakecredentialrequest != nullptr) {
+ set_has_pakecredentialrequest();
+ data_.pakecredentialrequest_.UnsafeSetDefault(pakecredentialrequest);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakecredentialrequest);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationRequestData.pakeCredentialRequest)
+}
+
+// bytes pakeCredentialFinalization = 4;
+inline bool PakeAuthenticationRequestData::_internal_has_pakecredentialfinalization() const {
+ return data_case() == kPakeCredentialFinalization;
+}
+inline bool PakeAuthenticationRequestData::has_pakecredentialfinalization() const {
+ return _internal_has_pakecredentialfinalization();
+}
+inline void PakeAuthenticationRequestData::set_has_pakecredentialfinalization() {
+ _oneof_case_[0] = kPakeCredentialFinalization;
+}
+inline void PakeAuthenticationRequestData::clear_pakecredentialfinalization() {
+ if (_internal_has_pakecredentialfinalization()) {
+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationRequestData::pakecredentialfinalization() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+ return _internal_pakecredentialfinalization();
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialfinalization(const std::string& value) {
+ _internal_set_pakecredentialfinalization(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline std::string* PakeAuthenticationRequestData::mutable_pakecredentialfinalization() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+ return _internal_mutable_pakecredentialfinalization();
+}
+inline const std::string& PakeAuthenticationRequestData::_internal_pakecredentialfinalization() const {
+ if (_internal_has_pakecredentialfinalization()) {
+ return data_.pakecredentialfinalization_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationRequestData::_internal_set_pakecredentialfinalization(const std::string& value) {
+ if (!_internal_has_pakecredentialfinalization()) {
+ clear_data();
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialfinalization(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+ if (!_internal_has_pakecredentialfinalization()) {
+ clear_data();
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialfinalization_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialfinalization(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakecredentialfinalization()) {
+ clear_data();
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialfinalization_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline void PakeAuthenticationRequestData::set_pakecredentialfinalization(const void* value,
+ size_t size) {
+ if (!_internal_has_pakecredentialfinalization()) {
+ clear_data();
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialfinalization_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+}
+inline std::string* PakeAuthenticationRequestData::_internal_mutable_pakecredentialfinalization() {
+ if (!_internal_has_pakecredentialfinalization()) {
+ clear_data();
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakecredentialfinalization_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationRequestData::release_pakecredentialfinalization() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+ if (_internal_has_pakecredentialfinalization()) {
+ clear_has_data();
+ return data_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationRequestData::set_allocated_pakecredentialfinalization(std::string* pakecredentialfinalization) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakecredentialfinalization != nullptr) {
+ set_has_pakecredentialfinalization();
+ data_.pakecredentialfinalization_.UnsafeSetDefault(pakecredentialfinalization);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakecredentialfinalization);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationRequestData.pakeCredentialFinalization)
+}
+
+// bytes pakeClientMAC = 5;
+inline bool PakeAuthenticationRequestData::_internal_has_pakeclientmac() const {
+ return data_case() == kPakeClientMAC;
+}
+inline bool PakeAuthenticationRequestData::has_pakeclientmac() const {
+ return _internal_has_pakeclientmac();
+}
+inline void PakeAuthenticationRequestData::set_has_pakeclientmac() {
+ _oneof_case_[0] = kPakeClientMAC;
+}
+inline void PakeAuthenticationRequestData::clear_pakeclientmac() {
+ if (_internal_has_pakeclientmac()) {
+ data_.pakeclientmac_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationRequestData::pakeclientmac() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationRequestData.pakeClientMAC)
+ return _internal_pakeclientmac();
+}
+inline void PakeAuthenticationRequestData::set_pakeclientmac(const std::string& value) {
+ _internal_set_pakeclientmac(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeClientMAC)
+}
+inline std::string* PakeAuthenticationRequestData::mutable_pakeclientmac() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationRequestData.pakeClientMAC)
+ return _internal_mutable_pakeclientmac();
+}
+inline const std::string& PakeAuthenticationRequestData::_internal_pakeclientmac() const {
+ if (_internal_has_pakeclientmac()) {
+ return data_.pakeclientmac_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationRequestData::_internal_set_pakeclientmac(const std::string& value) {
+ if (!_internal_has_pakeclientmac()) {
+ clear_data();
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeclientmac_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationRequestData::set_pakeclientmac(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationRequestData.pakeClientMAC)
+ if (!_internal_has_pakeclientmac()) {
+ clear_data();
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeclientmac_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationRequestData.pakeClientMAC)
+}
+inline void PakeAuthenticationRequestData::set_pakeclientmac(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakeclientmac()) {
+ clear_data();
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeclientmac_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationRequestData.pakeClientMAC)
+}
+inline void PakeAuthenticationRequestData::set_pakeclientmac(const void* value,
+ size_t size) {
+ if (!_internal_has_pakeclientmac()) {
+ clear_data();
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeclientmac_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationRequestData.pakeClientMAC)
+}
+inline std::string* PakeAuthenticationRequestData::_internal_mutable_pakeclientmac() {
+ if (!_internal_has_pakeclientmac()) {
+ clear_data();
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakeclientmac_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationRequestData::release_pakeclientmac() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationRequestData.pakeClientMAC)
+ if (_internal_has_pakeclientmac()) {
+ clear_has_data();
+ return data_.pakeclientmac_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationRequestData::set_allocated_pakeclientmac(std::string* pakeclientmac) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakeclientmac != nullptr) {
+ set_has_pakeclientmac();
+ data_.pakeclientmac_.UnsafeSetDefault(pakeclientmac);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakeclientmac);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationRequestData.pakeClientMAC)
+}
+
+inline bool PakeAuthenticationRequestData::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void PakeAuthenticationRequestData::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline PakeAuthenticationRequestData::DataCase PakeAuthenticationRequestData::data_case() const {
+ return PakeAuthenticationRequestData::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// WalletAuthenticationRequestData
+
+// string userID = 1;
+inline void WalletAuthenticationRequestData::clear_userid() {
+ userid_.ClearToEmpty();
+}
+inline const std::string& WalletAuthenticationRequestData::userid() const {
+ // @@protoc_insertion_point(field_get:backup.WalletAuthenticationRequestData.userID)
+ return _internal_userid();
+}
+inline void WalletAuthenticationRequestData::set_userid(const std::string& value) {
+ _internal_set_userid(value);
+ // @@protoc_insertion_point(field_set:backup.WalletAuthenticationRequestData.userID)
+}
+inline std::string* WalletAuthenticationRequestData::mutable_userid() {
+ // @@protoc_insertion_point(field_mutable:backup.WalletAuthenticationRequestData.userID)
+ return _internal_mutable_userid();
+}
+inline const std::string& WalletAuthenticationRequestData::_internal_userid() const {
+ return userid_.Get();
+}
+inline void WalletAuthenticationRequestData::_internal_set_userid(const std::string& value) {
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void WalletAuthenticationRequestData::set_userid(std::string&& value) {
+
+ userid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.WalletAuthenticationRequestData.userID)
+}
+inline void WalletAuthenticationRequestData::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.WalletAuthenticationRequestData.userID)
+}
+inline void WalletAuthenticationRequestData::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.WalletAuthenticationRequestData.userID)
+}
+inline std::string* WalletAuthenticationRequestData::_internal_mutable_userid() {
+
+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* WalletAuthenticationRequestData::release_userid() {
+ // @@protoc_insertion_point(field_release:backup.WalletAuthenticationRequestData.userID)
+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void WalletAuthenticationRequestData::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.WalletAuthenticationRequestData.userID)
+}
+
+// string walletAddress = 2;
+inline void WalletAuthenticationRequestData::clear_walletaddress() {
+ walletaddress_.ClearToEmpty();
+}
+inline const std::string& WalletAuthenticationRequestData::walletaddress() const {
+ // @@protoc_insertion_point(field_get:backup.WalletAuthenticationRequestData.walletAddress)
+ return _internal_walletaddress();
+}
+inline void WalletAuthenticationRequestData::set_walletaddress(const std::string& value) {
+ _internal_set_walletaddress(value);
+ // @@protoc_insertion_point(field_set:backup.WalletAuthenticationRequestData.walletAddress)
+}
+inline std::string* WalletAuthenticationRequestData::mutable_walletaddress() {
+ // @@protoc_insertion_point(field_mutable:backup.WalletAuthenticationRequestData.walletAddress)
+ return _internal_mutable_walletaddress();
+}
+inline const std::string& WalletAuthenticationRequestData::_internal_walletaddress() const {
+ return walletaddress_.Get();
+}
+inline void WalletAuthenticationRequestData::_internal_set_walletaddress(const std::string& value) {
+
+ walletaddress_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void WalletAuthenticationRequestData::set_walletaddress(std::string&& value) {
+
+ walletaddress_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.WalletAuthenticationRequestData.walletAddress)
+}
+inline void WalletAuthenticationRequestData::set_walletaddress(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ walletaddress_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.WalletAuthenticationRequestData.walletAddress)
+}
+inline void WalletAuthenticationRequestData::set_walletaddress(const char* value,
+ size_t size) {
+
+ walletaddress_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.WalletAuthenticationRequestData.walletAddress)
+}
+inline std::string* WalletAuthenticationRequestData::_internal_mutable_walletaddress() {
+
+ return walletaddress_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* WalletAuthenticationRequestData::release_walletaddress() {
+ // @@protoc_insertion_point(field_release:backup.WalletAuthenticationRequestData.walletAddress)
+ return walletaddress_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void WalletAuthenticationRequestData::set_allocated_walletaddress(std::string* walletaddress) {
+ if (walletaddress != nullptr) {
+
+ } else {
+
+ }
+ walletaddress_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), walletaddress,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.WalletAuthenticationRequestData.walletAddress)
+}
+
+// bytes signedMessage = 3;
+inline void WalletAuthenticationRequestData::clear_signedmessage() {
+ signedmessage_.ClearToEmpty();
+}
+inline const std::string& WalletAuthenticationRequestData::signedmessage() const {
+ // @@protoc_insertion_point(field_get:backup.WalletAuthenticationRequestData.signedMessage)
+ return _internal_signedmessage();
+}
+inline void WalletAuthenticationRequestData::set_signedmessage(const std::string& value) {
+ _internal_set_signedmessage(value);
+ // @@protoc_insertion_point(field_set:backup.WalletAuthenticationRequestData.signedMessage)
+}
+inline std::string* WalletAuthenticationRequestData::mutable_signedmessage() {
+ // @@protoc_insertion_point(field_mutable:backup.WalletAuthenticationRequestData.signedMessage)
+ return _internal_mutable_signedmessage();
+}
+inline const std::string& WalletAuthenticationRequestData::_internal_signedmessage() const {
+ return signedmessage_.Get();
+}
+inline void WalletAuthenticationRequestData::_internal_set_signedmessage(const std::string& value) {
+
+ signedmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void WalletAuthenticationRequestData::set_signedmessage(std::string&& value) {
+
+ signedmessage_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.WalletAuthenticationRequestData.signedMessage)
+}
+inline void WalletAuthenticationRequestData::set_signedmessage(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ signedmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.WalletAuthenticationRequestData.signedMessage)
+}
+inline void WalletAuthenticationRequestData::set_signedmessage(const void* value,
+ size_t size) {
+
+ signedmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.WalletAuthenticationRequestData.signedMessage)
+}
+inline std::string* WalletAuthenticationRequestData::_internal_mutable_signedmessage() {
+
+ return signedmessage_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* WalletAuthenticationRequestData::release_signedmessage() {
+ // @@protoc_insertion_point(field_release:backup.WalletAuthenticationRequestData.signedMessage)
+ return signedmessage_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void WalletAuthenticationRequestData::set_allocated_signedmessage(std::string* signedmessage) {
+ if (signedmessage != nullptr) {
+
+ } else {
+
+ }
+ signedmessage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signedmessage,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.WalletAuthenticationRequestData.signedMessage)
+}
+
+// -------------------------------------------------------------------
+
+// FullAuthenticationRequestData
+
+// .backup.PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+inline bool FullAuthenticationRequestData::_internal_has_pakeauthenticationrequestdata() const {
+ return data_case() == kPakeAuthenticationRequestData;
+}
+inline bool FullAuthenticationRequestData::has_pakeauthenticationrequestdata() const {
+ return _internal_has_pakeauthenticationrequestdata();
+}
+inline void FullAuthenticationRequestData::set_has_pakeauthenticationrequestdata() {
+ _oneof_case_[0] = kPakeAuthenticationRequestData;
+}
+inline void FullAuthenticationRequestData::clear_pakeauthenticationrequestdata() {
+ if (_internal_has_pakeauthenticationrequestdata()) {
+ if (GetArena() == nullptr) {
+ delete data_.pakeauthenticationrequestdata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::PakeAuthenticationRequestData* FullAuthenticationRequestData::release_pakeauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+ if (_internal_has_pakeauthenticationrequestdata()) {
+ clear_has_data();
+ ::backup::PakeAuthenticationRequestData* temp = data_.pakeauthenticationrequestdata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.pakeauthenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::PakeAuthenticationRequestData& FullAuthenticationRequestData::_internal_pakeauthenticationrequestdata() const {
+ return _internal_has_pakeauthenticationrequestdata()
+ ? *data_.pakeauthenticationrequestdata_
+ : reinterpret_cast< ::backup::PakeAuthenticationRequestData&>(::backup::_PakeAuthenticationRequestData_default_instance_);
+}
+inline const ::backup::PakeAuthenticationRequestData& FullAuthenticationRequestData::pakeauthenticationrequestdata() const {
+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+ return _internal_pakeauthenticationrequestdata();
+}
+inline ::backup::PakeAuthenticationRequestData* FullAuthenticationRequestData::unsafe_arena_release_pakeauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+ if (_internal_has_pakeauthenticationrequestdata()) {
+ clear_has_data();
+ ::backup::PakeAuthenticationRequestData* temp = data_.pakeauthenticationrequestdata_;
+ data_.pakeauthenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void FullAuthenticationRequestData::unsafe_arena_set_allocated_pakeauthenticationrequestdata(::backup::PakeAuthenticationRequestData* pakeauthenticationrequestdata) {
+ clear_data();
+ if (pakeauthenticationrequestdata) {
+ set_has_pakeauthenticationrequestdata();
+ data_.pakeauthenticationrequestdata_ = pakeauthenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+}
+inline ::backup::PakeAuthenticationRequestData* FullAuthenticationRequestData::_internal_mutable_pakeauthenticationrequestdata() {
+ if (!_internal_has_pakeauthenticationrequestdata()) {
+ clear_data();
+ set_has_pakeauthenticationrequestdata();
+ data_.pakeauthenticationrequestdata_ = CreateMaybeMessage< ::backup::PakeAuthenticationRequestData >(GetArena());
+ }
+ return data_.pakeauthenticationrequestdata_;
+}
+inline ::backup::PakeAuthenticationRequestData* FullAuthenticationRequestData::mutable_pakeauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+ return _internal_mutable_pakeauthenticationrequestdata();
+}
+
+// .backup.WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+inline bool FullAuthenticationRequestData::_internal_has_walletauthenticationrequestdata() const {
+ return data_case() == kWalletAuthenticationRequestData;
+}
+inline bool FullAuthenticationRequestData::has_walletauthenticationrequestdata() const {
+ return _internal_has_walletauthenticationrequestdata();
+}
+inline void FullAuthenticationRequestData::set_has_walletauthenticationrequestdata() {
+ _oneof_case_[0] = kWalletAuthenticationRequestData;
+}
+inline void FullAuthenticationRequestData::clear_walletauthenticationrequestdata() {
+ if (_internal_has_walletauthenticationrequestdata()) {
+ if (GetArena() == nullptr) {
+ delete data_.walletauthenticationrequestdata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::WalletAuthenticationRequestData* FullAuthenticationRequestData::release_walletauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+ if (_internal_has_walletauthenticationrequestdata()) {
+ clear_has_data();
+ ::backup::WalletAuthenticationRequestData* temp = data_.walletauthenticationrequestdata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.walletauthenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::WalletAuthenticationRequestData& FullAuthenticationRequestData::_internal_walletauthenticationrequestdata() const {
+ return _internal_has_walletauthenticationrequestdata()
+ ? *data_.walletauthenticationrequestdata_
+ : reinterpret_cast< ::backup::WalletAuthenticationRequestData&>(::backup::_WalletAuthenticationRequestData_default_instance_);
+}
+inline const ::backup::WalletAuthenticationRequestData& FullAuthenticationRequestData::walletauthenticationrequestdata() const {
+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+ return _internal_walletauthenticationrequestdata();
+}
+inline ::backup::WalletAuthenticationRequestData* FullAuthenticationRequestData::unsafe_arena_release_walletauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+ if (_internal_has_walletauthenticationrequestdata()) {
+ clear_has_data();
+ ::backup::WalletAuthenticationRequestData* temp = data_.walletauthenticationrequestdata_;
+ data_.walletauthenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void FullAuthenticationRequestData::unsafe_arena_set_allocated_walletauthenticationrequestdata(::backup::WalletAuthenticationRequestData* walletauthenticationrequestdata) {
+ clear_data();
+ if (walletauthenticationrequestdata) {
+ set_has_walletauthenticationrequestdata();
+ data_.walletauthenticationrequestdata_ = walletauthenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+}
+inline ::backup::WalletAuthenticationRequestData* FullAuthenticationRequestData::_internal_mutable_walletauthenticationrequestdata() {
+ if (!_internal_has_walletauthenticationrequestdata()) {
+ clear_data();
+ set_has_walletauthenticationrequestdata();
+ data_.walletauthenticationrequestdata_ = CreateMaybeMessage< ::backup::WalletAuthenticationRequestData >(GetArena());
+ }
+ return data_.walletauthenticationrequestdata_;
+}
+inline ::backup::WalletAuthenticationRequestData* FullAuthenticationRequestData::mutable_walletauthenticationrequestdata() {
+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+ return _internal_mutable_walletauthenticationrequestdata();
+}
+
+inline bool FullAuthenticationRequestData::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void FullAuthenticationRequestData::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline FullAuthenticationRequestData::DataCase FullAuthenticationRequestData::data_case() const {
+ return FullAuthenticationRequestData::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// WalletAuthenticationResponseData
+
+// bool success = 1;
+inline void WalletAuthenticationResponseData::clear_success() {
+ success_ = false;
+}
+inline bool WalletAuthenticationResponseData::_internal_success() const {
+ return success_;
+}
+inline bool WalletAuthenticationResponseData::success() const {
+ // @@protoc_insertion_point(field_get:backup.WalletAuthenticationResponseData.success)
+ return _internal_success();
+}
+inline void WalletAuthenticationResponseData::_internal_set_success(bool value) {
+
+ success_ = value;
+}
+inline void WalletAuthenticationResponseData::set_success(bool value) {
+ _internal_set_success(value);
+ // @@protoc_insertion_point(field_set:backup.WalletAuthenticationResponseData.success)
+}
+
+// -------------------------------------------------------------------
+
+// PakeAuthenticationResponseData
+
+// bytes pakeRegistrationResponse = 1;
+inline bool PakeAuthenticationResponseData::_internal_has_pakeregistrationresponse() const {
+ return data_case() == kPakeRegistrationResponse;
+}
+inline bool PakeAuthenticationResponseData::has_pakeregistrationresponse() const {
+ return _internal_has_pakeregistrationresponse();
+}
+inline void PakeAuthenticationResponseData::set_has_pakeregistrationresponse() {
+ _oneof_case_[0] = kPakeRegistrationResponse;
+}
+inline void PakeAuthenticationResponseData::clear_pakeregistrationresponse() {
+ if (_internal_has_pakeregistrationresponse()) {
+ data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationResponseData::pakeregistrationresponse() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+ return _internal_pakeregistrationresponse();
+}
+inline void PakeAuthenticationResponseData::set_pakeregistrationresponse(const std::string& value) {
+ _internal_set_pakeregistrationresponse(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline std::string* PakeAuthenticationResponseData::mutable_pakeregistrationresponse() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+ return _internal_mutable_pakeregistrationresponse();
+}
+inline const std::string& PakeAuthenticationResponseData::_internal_pakeregistrationresponse() const {
+ if (_internal_has_pakeregistrationresponse()) {
+ return data_.pakeregistrationresponse_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationResponseData::_internal_set_pakeregistrationresponse(const std::string& value) {
+ if (!_internal_has_pakeregistrationresponse()) {
+ clear_data();
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationResponseData::set_pakeregistrationresponse(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+ if (!_internal_has_pakeregistrationresponse()) {
+ clear_data();
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationresponse_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline void PakeAuthenticationResponseData::set_pakeregistrationresponse(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakeregistrationresponse()) {
+ clear_data();
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline void PakeAuthenticationResponseData::set_pakeregistrationresponse(const void* value,
+ size_t size) {
+ if (!_internal_has_pakeregistrationresponse()) {
+ clear_data();
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeregistrationresponse_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+}
+inline std::string* PakeAuthenticationResponseData::_internal_mutable_pakeregistrationresponse() {
+ if (!_internal_has_pakeregistrationresponse()) {
+ clear_data();
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakeregistrationresponse_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationResponseData::release_pakeregistrationresponse() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+ if (_internal_has_pakeregistrationresponse()) {
+ clear_has_data();
+ return data_.pakeregistrationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationResponseData::set_allocated_pakeregistrationresponse(std::string* pakeregistrationresponse) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakeregistrationresponse != nullptr) {
+ set_has_pakeregistrationresponse();
+ data_.pakeregistrationresponse_.UnsafeSetDefault(pakeregistrationresponse);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakeregistrationresponse);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationResponseData.pakeRegistrationResponse)
+}
+
+// bool pakeRegistrationSuccess = 2;
+inline bool PakeAuthenticationResponseData::_internal_has_pakeregistrationsuccess() const {
+ return data_case() == kPakeRegistrationSuccess;
+}
+inline bool PakeAuthenticationResponseData::has_pakeregistrationsuccess() const {
+ return _internal_has_pakeregistrationsuccess();
+}
+inline void PakeAuthenticationResponseData::set_has_pakeregistrationsuccess() {
+ _oneof_case_[0] = kPakeRegistrationSuccess;
+}
+inline void PakeAuthenticationResponseData::clear_pakeregistrationsuccess() {
+ if (_internal_has_pakeregistrationsuccess()) {
+ data_.pakeregistrationsuccess_ = false;
+ clear_has_data();
+ }
+}
+inline bool PakeAuthenticationResponseData::_internal_pakeregistrationsuccess() const {
+ if (_internal_has_pakeregistrationsuccess()) {
+ return data_.pakeregistrationsuccess_;
+ }
+ return false;
+}
+inline void PakeAuthenticationResponseData::_internal_set_pakeregistrationsuccess(bool value) {
+ if (!_internal_has_pakeregistrationsuccess()) {
+ clear_data();
+ set_has_pakeregistrationsuccess();
+ }
+ data_.pakeregistrationsuccess_ = value;
+}
+inline bool PakeAuthenticationResponseData::pakeregistrationsuccess() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationResponseData.pakeRegistrationSuccess)
+ return _internal_pakeregistrationsuccess();
+}
+inline void PakeAuthenticationResponseData::set_pakeregistrationsuccess(bool value) {
+ _internal_set_pakeregistrationsuccess(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeRegistrationSuccess)
+}
+
+// bytes pakeCredentialResponse = 3;
+inline bool PakeAuthenticationResponseData::_internal_has_pakecredentialresponse() const {
+ return data_case() == kPakeCredentialResponse;
+}
+inline bool PakeAuthenticationResponseData::has_pakecredentialresponse() const {
+ return _internal_has_pakecredentialresponse();
+}
+inline void PakeAuthenticationResponseData::set_has_pakecredentialresponse() {
+ _oneof_case_[0] = kPakeCredentialResponse;
+}
+inline void PakeAuthenticationResponseData::clear_pakecredentialresponse() {
+ if (_internal_has_pakecredentialresponse()) {
+ data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationResponseData::pakecredentialresponse() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+ return _internal_pakecredentialresponse();
+}
+inline void PakeAuthenticationResponseData::set_pakecredentialresponse(const std::string& value) {
+ _internal_set_pakecredentialresponse(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+}
+inline std::string* PakeAuthenticationResponseData::mutable_pakecredentialresponse() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+ return _internal_mutable_pakecredentialresponse();
+}
+inline const std::string& PakeAuthenticationResponseData::_internal_pakecredentialresponse() const {
+ if (_internal_has_pakecredentialresponse()) {
+ return data_.pakecredentialresponse_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationResponseData::_internal_set_pakecredentialresponse(const std::string& value) {
+ if (!_internal_has_pakecredentialresponse()) {
+ clear_data();
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationResponseData::set_pakecredentialresponse(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+ if (!_internal_has_pakecredentialresponse()) {
+ clear_data();
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialresponse_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+}
+inline void PakeAuthenticationResponseData::set_pakecredentialresponse(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakecredentialresponse()) {
+ clear_data();
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialresponse_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+}
+inline void PakeAuthenticationResponseData::set_pakecredentialresponse(const void* value,
+ size_t size) {
+ if (!_internal_has_pakecredentialresponse()) {
+ clear_data();
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakecredentialresponse_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+}
+inline std::string* PakeAuthenticationResponseData::_internal_mutable_pakecredentialresponse() {
+ if (!_internal_has_pakecredentialresponse()) {
+ clear_data();
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakecredentialresponse_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationResponseData::release_pakecredentialresponse() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+ if (_internal_has_pakecredentialresponse()) {
+ clear_has_data();
+ return data_.pakecredentialresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationResponseData::set_allocated_pakecredentialresponse(std::string* pakecredentialresponse) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakecredentialresponse != nullptr) {
+ set_has_pakecredentialresponse();
+ data_.pakecredentialresponse_.UnsafeSetDefault(pakecredentialresponse);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakecredentialresponse);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationResponseData.pakeCredentialResponse)
+}
+
+// bytes pakeServerMAC = 4;
+inline bool PakeAuthenticationResponseData::_internal_has_pakeservermac() const {
+ return data_case() == kPakeServerMAC;
+}
+inline bool PakeAuthenticationResponseData::has_pakeservermac() const {
+ return _internal_has_pakeservermac();
+}
+inline void PakeAuthenticationResponseData::set_has_pakeservermac() {
+ _oneof_case_[0] = kPakeServerMAC;
+}
+inline void PakeAuthenticationResponseData::clear_pakeservermac() {
+ if (_internal_has_pakeservermac()) {
+ data_.pakeservermac_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& PakeAuthenticationResponseData::pakeservermac() const {
+ // @@protoc_insertion_point(field_get:backup.PakeAuthenticationResponseData.pakeServerMAC)
+ return _internal_pakeservermac();
+}
+inline void PakeAuthenticationResponseData::set_pakeservermac(const std::string& value) {
+ _internal_set_pakeservermac(value);
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeServerMAC)
+}
+inline std::string* PakeAuthenticationResponseData::mutable_pakeservermac() {
+ // @@protoc_insertion_point(field_mutable:backup.PakeAuthenticationResponseData.pakeServerMAC)
+ return _internal_mutable_pakeservermac();
+}
+inline const std::string& PakeAuthenticationResponseData::_internal_pakeservermac() const {
+ if (_internal_has_pakeservermac()) {
+ return data_.pakeservermac_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void PakeAuthenticationResponseData::_internal_set_pakeservermac(const std::string& value) {
+ if (!_internal_has_pakeservermac()) {
+ clear_data();
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeservermac_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void PakeAuthenticationResponseData::set_pakeservermac(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PakeAuthenticationResponseData.pakeServerMAC)
+ if (!_internal_has_pakeservermac()) {
+ clear_data();
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeservermac_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.PakeAuthenticationResponseData.pakeServerMAC)
+}
+inline void PakeAuthenticationResponseData::set_pakeservermac(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_pakeservermac()) {
+ clear_data();
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeservermac_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.PakeAuthenticationResponseData.pakeServerMAC)
+}
+inline void PakeAuthenticationResponseData::set_pakeservermac(const void* value,
+ size_t size) {
+ if (!_internal_has_pakeservermac()) {
+ clear_data();
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.pakeservermac_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.PakeAuthenticationResponseData.pakeServerMAC)
+}
+inline std::string* PakeAuthenticationResponseData::_internal_mutable_pakeservermac() {
+ if (!_internal_has_pakeservermac()) {
+ clear_data();
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.pakeservermac_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* PakeAuthenticationResponseData::release_pakeservermac() {
+ // @@protoc_insertion_point(field_release:backup.PakeAuthenticationResponseData.pakeServerMAC)
+ if (_internal_has_pakeservermac()) {
+ clear_has_data();
+ return data_.pakeservermac_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void PakeAuthenticationResponseData::set_allocated_pakeservermac(std::string* pakeservermac) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (pakeservermac != nullptr) {
+ set_has_pakeservermac();
+ data_.pakeservermac_.UnsafeSetDefault(pakeservermac);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(pakeservermac);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationResponseData.pakeServerMAC)
+}
+
+inline bool PakeAuthenticationResponseData::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void PakeAuthenticationResponseData::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline PakeAuthenticationResponseData::DataCase PakeAuthenticationResponseData::data_case() const {
+ return PakeAuthenticationResponseData::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FullAuthenticationResponseData
+
+// .backup.PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+inline bool FullAuthenticationResponseData::_internal_has_pakeauthenticationresponsedata() const {
+ return data_case() == kPakeAuthenticationResponseData;
+}
+inline bool FullAuthenticationResponseData::has_pakeauthenticationresponsedata() const {
+ return _internal_has_pakeauthenticationresponsedata();
+}
+inline void FullAuthenticationResponseData::set_has_pakeauthenticationresponsedata() {
+ _oneof_case_[0] = kPakeAuthenticationResponseData;
+}
+inline void FullAuthenticationResponseData::clear_pakeauthenticationresponsedata() {
+ if (_internal_has_pakeauthenticationresponsedata()) {
+ if (GetArena() == nullptr) {
+ delete data_.pakeauthenticationresponsedata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::PakeAuthenticationResponseData* FullAuthenticationResponseData::release_pakeauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+ if (_internal_has_pakeauthenticationresponsedata()) {
+ clear_has_data();
+ ::backup::PakeAuthenticationResponseData* temp = data_.pakeauthenticationresponsedata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.pakeauthenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::PakeAuthenticationResponseData& FullAuthenticationResponseData::_internal_pakeauthenticationresponsedata() const {
+ return _internal_has_pakeauthenticationresponsedata()
+ ? *data_.pakeauthenticationresponsedata_
+ : reinterpret_cast< ::backup::PakeAuthenticationResponseData&>(::backup::_PakeAuthenticationResponseData_default_instance_);
+}
+inline const ::backup::PakeAuthenticationResponseData& FullAuthenticationResponseData::pakeauthenticationresponsedata() const {
+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+ return _internal_pakeauthenticationresponsedata();
+}
+inline ::backup::PakeAuthenticationResponseData* FullAuthenticationResponseData::unsafe_arena_release_pakeauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+ if (_internal_has_pakeauthenticationresponsedata()) {
+ clear_has_data();
+ ::backup::PakeAuthenticationResponseData* temp = data_.pakeauthenticationresponsedata_;
+ data_.pakeauthenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void FullAuthenticationResponseData::unsafe_arena_set_allocated_pakeauthenticationresponsedata(::backup::PakeAuthenticationResponseData* pakeauthenticationresponsedata) {
+ clear_data();
+ if (pakeauthenticationresponsedata) {
+ set_has_pakeauthenticationresponsedata();
+ data_.pakeauthenticationresponsedata_ = pakeauthenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+}
+inline ::backup::PakeAuthenticationResponseData* FullAuthenticationResponseData::_internal_mutable_pakeauthenticationresponsedata() {
+ if (!_internal_has_pakeauthenticationresponsedata()) {
+ clear_data();
+ set_has_pakeauthenticationresponsedata();
+ data_.pakeauthenticationresponsedata_ = CreateMaybeMessage< ::backup::PakeAuthenticationResponseData >(GetArena());
+ }
+ return data_.pakeauthenticationresponsedata_;
+}
+inline ::backup::PakeAuthenticationResponseData* FullAuthenticationResponseData::mutable_pakeauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+ return _internal_mutable_pakeauthenticationresponsedata();
+}
+
+// .backup.WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+inline bool FullAuthenticationResponseData::_internal_has_walletauthenticationresponsedata() const {
+ return data_case() == kWalletAuthenticationResponseData;
+}
+inline bool FullAuthenticationResponseData::has_walletauthenticationresponsedata() const {
+ return _internal_has_walletauthenticationresponsedata();
+}
+inline void FullAuthenticationResponseData::set_has_walletauthenticationresponsedata() {
+ _oneof_case_[0] = kWalletAuthenticationResponseData;
+}
+inline void FullAuthenticationResponseData::clear_walletauthenticationresponsedata() {
+ if (_internal_has_walletauthenticationresponsedata()) {
+ if (GetArena() == nullptr) {
+ delete data_.walletauthenticationresponsedata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::WalletAuthenticationResponseData* FullAuthenticationResponseData::release_walletauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_release:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+ if (_internal_has_walletauthenticationresponsedata()) {
+ clear_has_data();
+ ::backup::WalletAuthenticationResponseData* temp = data_.walletauthenticationresponsedata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.walletauthenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::WalletAuthenticationResponseData& FullAuthenticationResponseData::_internal_walletauthenticationresponsedata() const {
+ return _internal_has_walletauthenticationresponsedata()
+ ? *data_.walletauthenticationresponsedata_
+ : reinterpret_cast< ::backup::WalletAuthenticationResponseData&>(::backup::_WalletAuthenticationResponseData_default_instance_);
+}
+inline const ::backup::WalletAuthenticationResponseData& FullAuthenticationResponseData::walletauthenticationresponsedata() const {
+ // @@protoc_insertion_point(field_get:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+ return _internal_walletauthenticationresponsedata();
+}
+inline ::backup::WalletAuthenticationResponseData* FullAuthenticationResponseData::unsafe_arena_release_walletauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+ if (_internal_has_walletauthenticationresponsedata()) {
+ clear_has_data();
+ ::backup::WalletAuthenticationResponseData* temp = data_.walletauthenticationresponsedata_;
+ data_.walletauthenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void FullAuthenticationResponseData::unsafe_arena_set_allocated_walletauthenticationresponsedata(::backup::WalletAuthenticationResponseData* walletauthenticationresponsedata) {
+ clear_data();
+ if (walletauthenticationresponsedata) {
+ set_has_walletauthenticationresponsedata();
+ data_.walletauthenticationresponsedata_ = walletauthenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+}
+inline ::backup::WalletAuthenticationResponseData* FullAuthenticationResponseData::_internal_mutable_walletauthenticationresponsedata() {
+ if (!_internal_has_walletauthenticationresponsedata()) {
+ clear_data();
+ set_has_walletauthenticationresponsedata();
+ data_.walletauthenticationresponsedata_ = CreateMaybeMessage< ::backup::WalletAuthenticationResponseData >(GetArena());
+ }
+ return data_.walletauthenticationresponsedata_;
+}
+inline ::backup::WalletAuthenticationResponseData* FullAuthenticationResponseData::mutable_walletauthenticationresponsedata() {
+ // @@protoc_insertion_point(field_mutable:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+ return _internal_mutable_walletauthenticationresponsedata();
+}
+
+inline bool FullAuthenticationResponseData::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void FullAuthenticationResponseData::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline FullAuthenticationResponseData::DataCase FullAuthenticationResponseData::data_case() const {
+ return FullAuthenticationResponseData::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// SimpleAuthenticationRequestData
+
+// string backupID = 1;
+inline void SimpleAuthenticationRequestData::clear_backupid() {
+ backupid_.ClearToEmpty();
+}
+inline const std::string& SimpleAuthenticationRequestData::backupid() const {
+ // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.backupID)
+ return _internal_backupid();
+}
+inline void SimpleAuthenticationRequestData::set_backupid(const std::string& value) {
+ _internal_set_backupid(value);
+ // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline std::string* SimpleAuthenticationRequestData::mutable_backupid() {
+ // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.backupID)
+ return _internal_mutable_backupid();
+}
+inline const std::string& SimpleAuthenticationRequestData::_internal_backupid() const {
+ return backupid_.Get();
+}
+inline void SimpleAuthenticationRequestData::_internal_set_backupid(const std::string& value) {
+
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SimpleAuthenticationRequestData::set_backupid(std::string&& value) {
+
+ backupid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline void SimpleAuthenticationRequestData::set_backupid(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline void SimpleAuthenticationRequestData::set_backupid(const char* value,
+ size_t size) {
+
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.SimpleAuthenticationRequestData.backupID)
+}
+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_backupid() {
+
+ return backupid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SimpleAuthenticationRequestData::release_backupid() {
+ // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.backupID)
+ return backupid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SimpleAuthenticationRequestData::set_allocated_backupid(std::string* backupid) {
+ if (backupid != nullptr) {
+
+ } else {
+
+ }
+ backupid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), backupid,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:backup.SimpleAuthenticationRequestData.backupID)
+}
+
+// string userID = 2;
+inline void SimpleAuthenticationRequestData::clear_userid() {
+ userid_.ClearToEmpty();
+}
+inline const std::string& SimpleAuthenticationRequestData::userid() const {
+ // @@protoc_insertion_point(field_get:backup.SimpleAuthenticationRequestData.userID)
+ return _internal_userid();
+}
+inline void SimpleAuthenticationRequestData::set_userid(const std::string& value) {
+ _internal_set_userid(value);
+ // @@protoc_insertion_point(field_set:backup.SimpleAuthenticationRequestData.userID)
+}
+inline std::string* SimpleAuthenticationRequestData::mutable_userid() {
+ // @@protoc_insertion_point(field_mutable:backup.SimpleAuthenticationRequestData.userID)
+ return _internal_mutable_userid();
+}
+inline const std::string& SimpleAuthenticationRequestData::_internal_userid() const {
+ return userid_.Get();
+}
+inline void SimpleAuthenticationRequestData::_internal_set_userid(const std::string& value) {
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SimpleAuthenticationRequestData::set_userid(std::string&& value) {
+
+ userid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.SimpleAuthenticationRequestData.userID)
+}
+inline void SimpleAuthenticationRequestData::set_userid(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.SimpleAuthenticationRequestData.userID)
+}
+inline void SimpleAuthenticationRequestData::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.SimpleAuthenticationRequestData.userID)
+}
+inline std::string* SimpleAuthenticationRequestData::_internal_mutable_userid() {
+
+ return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SimpleAuthenticationRequestData::release_userid() {
+ // @@protoc_insertion_point(field_release:backup.SimpleAuthenticationRequestData.userID)
+ return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SimpleAuthenticationRequestData::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.SimpleAuthenticationRequestData.userID)
+}
+
+// -------------------------------------------------------------------
+
+// BackupKeyEntropy
+
+// bytes nonce = 1;
+inline bool BackupKeyEntropy::_internal_has_nonce() const {
+ return data_case() == kNonce;
+}
+inline bool BackupKeyEntropy::has_nonce() const {
+ return _internal_has_nonce();
}
-inline void ResetKeyRequest::clear_newkey() {
- if (_internal_has_newkey()) {
- data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void BackupKeyEntropy::set_has_nonce() {
+ _oneof_case_[0] = kNonce;
+}
+inline void BackupKeyEntropy::clear_nonce() {
+ if (_internal_has_nonce()) {
+ data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
clear_has_data();
}
}
-inline const std::string& ResetKeyRequest::newkey() const {
- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.newKey)
- return _internal_newkey();
+inline const std::string& BackupKeyEntropy::nonce() const {
+ // @@protoc_insertion_point(field_get:backup.BackupKeyEntropy.nonce)
+ return _internal_nonce();
}
-inline void ResetKeyRequest::set_newkey(const std::string& value) {
- _internal_set_newkey(value);
- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
+inline void BackupKeyEntropy::set_nonce(const std::string& value) {
+ _internal_set_nonce(value);
+ // @@protoc_insertion_point(field_set:backup.BackupKeyEntropy.nonce)
}
-inline std::string* ResetKeyRequest::mutable_newkey() {
- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.newKey)
- return _internal_mutable_newkey();
+inline std::string* BackupKeyEntropy::mutable_nonce() {
+ // @@protoc_insertion_point(field_mutable:backup.BackupKeyEntropy.nonce)
+ return _internal_mutable_nonce();
}
-inline const std::string& ResetKeyRequest::_internal_newkey() const {
- if (_internal_has_newkey()) {
- return data_.newkey_.Get();
+inline const std::string& BackupKeyEntropy::_internal_nonce() const {
+ if (_internal_has_nonce()) {
+ return data_.nonce_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
-inline void ResetKeyRequest::_internal_set_newkey(const std::string& value) {
- if (!_internal_has_newkey()) {
+inline void BackupKeyEntropy::_internal_set_nonce(const std::string& value) {
+ if (!_internal_has_nonce()) {
clear_data();
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void ResetKeyRequest::set_newkey(std::string&& value) {
- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.newKey)
- if (!_internal_has_newkey()) {
+inline void BackupKeyEntropy::set_nonce(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.BackupKeyEntropy.nonce)
+ if (!_internal_has_nonce()) {
clear_data();
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.newkey_.Set(
+ data_.nonce_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.newKey)
+ // @@protoc_insertion_point(field_set_rvalue:backup.BackupKeyEntropy.nonce)
}
-inline void ResetKeyRequest::set_newkey(const char* value) {
+inline void BackupKeyEntropy::set_nonce(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- if (!_internal_has_newkey()) {
+ if (!_internal_has_nonce()) {
clear_data();
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.newkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ data_.nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.newKey)
+ // @@protoc_insertion_point(field_set_char:backup.BackupKeyEntropy.nonce)
}
-inline void ResetKeyRequest::set_newkey(const void* value,
+inline void BackupKeyEntropy::set_nonce(const void* value,
size_t size) {
- if (!_internal_has_newkey()) {
+ if (!_internal_has_nonce()) {
clear_data();
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.newkey_.Set(
+ data_.nonce_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size),
GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.newKey)
+ // @@protoc_insertion_point(field_set_pointer:backup.BackupKeyEntropy.nonce)
}
-inline std::string* ResetKeyRequest::_internal_mutable_newkey() {
- if (!_internal_has_newkey()) {
+inline std::string* BackupKeyEntropy::_internal_mutable_nonce() {
+ if (!_internal_has_nonce()) {
clear_data();
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- return data_.newkey_.Mutable(
+ return data_.nonce_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* ResetKeyRequest::release_newkey() {
- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.newKey)
- if (_internal_has_newkey()) {
+inline std::string* BackupKeyEntropy::release_nonce() {
+ // @@protoc_insertion_point(field_release:backup.BackupKeyEntropy.nonce)
+ if (_internal_has_nonce()) {
clear_has_data();
- return data_.newkey_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ return data_.nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
} else {
return nullptr;
}
}
-inline void ResetKeyRequest::set_allocated_newkey(std::string* newkey) {
+inline void BackupKeyEntropy::set_allocated_nonce(std::string* nonce) {
if (has_data()) {
clear_data();
}
- if (newkey != nullptr) {
- set_has_newkey();
- data_.newkey_.UnsafeSetDefault(newkey);
+ if (nonce != nullptr) {
+ set_has_nonce();
+ data_.nonce_.UnsafeSetDefault(nonce);
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
if (arena != nullptr) {
- arena->Own(newkey);
+ arena->Own(nonce);
}
}
- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.newKey)
+ // @@protoc_insertion_point(field_set_allocated:backup.BackupKeyEntropy.nonce)
}
-// bytes compactionChunk = 3;
-inline bool ResetKeyRequest::_internal_has_compactionchunk() const {
- return data_case() == kCompactionChunk;
+// bytes rawMessage = 2;
+inline bool BackupKeyEntropy::_internal_has_rawmessage() const {
+ return data_case() == kRawMessage;
}
-inline bool ResetKeyRequest::has_compactionchunk() const {
- return _internal_has_compactionchunk();
+inline bool BackupKeyEntropy::has_rawmessage() const {
+ return _internal_has_rawmessage();
}
-inline void ResetKeyRequest::set_has_compactionchunk() {
- _oneof_case_[0] = kCompactionChunk;
+inline void BackupKeyEntropy::set_has_rawmessage() {
+ _oneof_case_[0] = kRawMessage;
}
-inline void ResetKeyRequest::clear_compactionchunk() {
- if (_internal_has_compactionchunk()) {
- data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void BackupKeyEntropy::clear_rawmessage() {
+ if (_internal_has_rawmessage()) {
+ data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
clear_has_data();
}
}
-inline const std::string& ResetKeyRequest::compactionchunk() const {
- // @@protoc_insertion_point(field_get:backup.ResetKeyRequest.compactionChunk)
- return _internal_compactionchunk();
+inline const std::string& BackupKeyEntropy::rawmessage() const {
+ // @@protoc_insertion_point(field_get:backup.BackupKeyEntropy.rawMessage)
+ return _internal_rawmessage();
}
-inline void ResetKeyRequest::set_compactionchunk(const std::string& value) {
- _internal_set_compactionchunk(value);
- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
+inline void BackupKeyEntropy::set_rawmessage(const std::string& value) {
+ _internal_set_rawmessage(value);
+ // @@protoc_insertion_point(field_set:backup.BackupKeyEntropy.rawMessage)
}
-inline std::string* ResetKeyRequest::mutable_compactionchunk() {
- // @@protoc_insertion_point(field_mutable:backup.ResetKeyRequest.compactionChunk)
- return _internal_mutable_compactionchunk();
+inline std::string* BackupKeyEntropy::mutable_rawmessage() {
+ // @@protoc_insertion_point(field_mutable:backup.BackupKeyEntropy.rawMessage)
+ return _internal_mutable_rawmessage();
}
-inline const std::string& ResetKeyRequest::_internal_compactionchunk() const {
- if (_internal_has_compactionchunk()) {
- return data_.compactionchunk_.Get();
+inline const std::string& BackupKeyEntropy::_internal_rawmessage() const {
+ if (_internal_has_rawmessage()) {
+ return data_.rawmessage_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
-inline void ResetKeyRequest::_internal_set_compactionchunk(const std::string& value) {
- if (!_internal_has_compactionchunk()) {
+inline void BackupKeyEntropy::_internal_set_rawmessage(const std::string& value) {
+ if (!_internal_has_rawmessage()) {
clear_data();
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void BackupKeyEntropy::set_rawmessage(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.BackupKeyEntropy.rawMessage)
+ if (!_internal_has_rawmessage()) {
+ clear_data();
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.rawmessage_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.BackupKeyEntropy.rawMessage)
+}
+inline void BackupKeyEntropy::set_rawmessage(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_rawmessage()) {
+ clear_data();
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.rawmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.BackupKeyEntropy.rawMessage)
+}
+inline void BackupKeyEntropy::set_rawmessage(const void* value,
+ size_t size) {
+ if (!_internal_has_rawmessage()) {
+ clear_data();
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.rawmessage_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.BackupKeyEntropy.rawMessage)
+}
+inline std::string* BackupKeyEntropy::_internal_mutable_rawmessage() {
+ if (!_internal_has_rawmessage()) {
+ clear_data();
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.rawmessage_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* BackupKeyEntropy::release_rawmessage() {
+ // @@protoc_insertion_point(field_release:backup.BackupKeyEntropy.rawMessage)
+ if (_internal_has_rawmessage()) {
+ clear_has_data();
+ return data_.rawmessage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void BackupKeyEntropy::set_allocated_rawmessage(std::string* rawmessage) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (rawmessage != nullptr) {
+ set_has_rawmessage();
+ data_.rawmessage_.UnsafeSetDefault(rawmessage);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(rawmessage);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.BackupKeyEntropy.rawMessage)
+}
+
+inline bool BackupKeyEntropy::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void BackupKeyEntropy::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline BackupKeyEntropy::DataCase BackupKeyEntropy::data_case() const {
+ return BackupKeyEntropy::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// CreateNewBackupRequest
+
+// .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+inline bool CreateNewBackupRequest::_internal_has_authenticationrequestdata() const {
+ return data_case() == kAuthenticationRequestData;
+}
+inline bool CreateNewBackupRequest::has_authenticationrequestdata() const {
+ return _internal_has_authenticationrequestdata();
+}
+inline void CreateNewBackupRequest::set_has_authenticationrequestdata() {
+ _oneof_case_[0] = kAuthenticationRequestData;
+}
+inline void CreateNewBackupRequest::clear_authenticationrequestdata() {
+ if (_internal_has_authenticationrequestdata()) {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationrequestdata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::release_authenticationrequestdata() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.authenticationRequestData)
+ if (_internal_has_authenticationrequestdata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.authenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::_internal_authenticationrequestdata() const {
+ return _internal_has_authenticationrequestdata()
+ ? *data_.authenticationrequestdata_
+ : reinterpret_cast< ::backup::FullAuthenticationRequestData&>(::backup::_FullAuthenticationRequestData_default_instance_);
+}
+inline const ::backup::FullAuthenticationRequestData& CreateNewBackupRequest::authenticationrequestdata() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.authenticationRequestData)
+ return _internal_authenticationrequestdata();
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::unsafe_arena_release_authenticationrequestdata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.authenticationRequestData)
+ if (_internal_has_authenticationrequestdata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationRequestData* temp = data_.authenticationrequestdata_;
+ data_.authenticationrequestdata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
+ clear_data();
+ if (authenticationrequestdata) {
+ set_has_authenticationrequestdata();
+ data_.authenticationrequestdata_ = authenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::_internal_mutable_authenticationrequestdata() {
+ if (!_internal_has_authenticationrequestdata()) {
+ clear_data();
+ set_has_authenticationrequestdata();
+ data_.authenticationrequestdata_ = CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(GetArena());
+ }
+ return data_.authenticationrequestdata_;
+}
+inline ::backup::FullAuthenticationRequestData* CreateNewBackupRequest::mutable_authenticationrequestdata() {
+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.authenticationRequestData)
+ return _internal_mutable_authenticationrequestdata();
+}
+
+// .backup.BackupKeyEntropy backupKeyEntropy = 2;
+inline bool CreateNewBackupRequest::_internal_has_backupkeyentropy() const {
+ return data_case() == kBackupKeyEntropy;
+}
+inline bool CreateNewBackupRequest::has_backupkeyentropy() const {
+ return _internal_has_backupkeyentropy();
+}
+inline void CreateNewBackupRequest::set_has_backupkeyentropy() {
+ _oneof_case_[0] = kBackupKeyEntropy;
+}
+inline void CreateNewBackupRequest::clear_backupkeyentropy() {
+ if (_internal_has_backupkeyentropy()) {
+ if (GetArena() == nullptr) {
+ delete data_.backupkeyentropy_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::BackupKeyEntropy* CreateNewBackupRequest::release_backupkeyentropy() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.backupKeyEntropy)
+ if (_internal_has_backupkeyentropy()) {
+ clear_has_data();
+ ::backup::BackupKeyEntropy* temp = data_.backupkeyentropy_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.backupkeyentropy_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::BackupKeyEntropy& CreateNewBackupRequest::_internal_backupkeyentropy() const {
+ return _internal_has_backupkeyentropy()
+ ? *data_.backupkeyentropy_
+ : reinterpret_cast< ::backup::BackupKeyEntropy&>(::backup::_BackupKeyEntropy_default_instance_);
+}
+inline const ::backup::BackupKeyEntropy& CreateNewBackupRequest::backupkeyentropy() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.backupKeyEntropy)
+ return _internal_backupkeyentropy();
+}
+inline ::backup::BackupKeyEntropy* CreateNewBackupRequest::unsafe_arena_release_backupkeyentropy() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupRequest.backupKeyEntropy)
+ if (_internal_has_backupkeyentropy()) {
+ clear_has_data();
+ ::backup::BackupKeyEntropy* temp = data_.backupkeyentropy_;
+ data_.backupkeyentropy_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void CreateNewBackupRequest::unsafe_arena_set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy) {
+ clear_data();
+ if (backupkeyentropy) {
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = backupkeyentropy;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupRequest.backupKeyEntropy)
+}
+inline ::backup::BackupKeyEntropy* CreateNewBackupRequest::_internal_mutable_backupkeyentropy() {
+ if (!_internal_has_backupkeyentropy()) {
+ clear_data();
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = CreateMaybeMessage< ::backup::BackupKeyEntropy >(GetArena());
+ }
+ return data_.backupkeyentropy_;
+}
+inline ::backup::BackupKeyEntropy* CreateNewBackupRequest::mutable_backupkeyentropy() {
+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.backupKeyEntropy)
+ return _internal_mutable_backupkeyentropy();
+}
+
+// bytes newCompactionChunk = 3;
+inline bool CreateNewBackupRequest::_internal_has_newcompactionchunk() const {
+ return data_case() == kNewCompactionChunk;
+}
+inline bool CreateNewBackupRequest::has_newcompactionchunk() const {
+ return _internal_has_newcompactionchunk();
+}
+inline void CreateNewBackupRequest::set_has_newcompactionchunk() {
+ _oneof_case_[0] = kNewCompactionChunk;
+}
+inline void CreateNewBackupRequest::clear_newcompactionchunk() {
+ if (_internal_has_newcompactionchunk()) {
+ data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& CreateNewBackupRequest::newcompactionchunk() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupRequest.newCompactionChunk)
+ return _internal_newcompactionchunk();
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const std::string& value) {
+ _internal_set_newcompactionchunk(value);
+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline std::string* CreateNewBackupRequest::mutable_newcompactionchunk() {
+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupRequest.newCompactionChunk)
+ return _internal_mutable_newcompactionchunk();
+}
+inline const std::string& CreateNewBackupRequest::_internal_newcompactionchunk() const {
+ if (_internal_has_newcompactionchunk()) {
+ return data_.newcompactionchunk_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void CreateNewBackupRequest::_internal_set_newcompactionchunk(const std::string& value) {
+ if (!_internal_has_newcompactionchunk()) {
+ clear_data();
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupRequest.newCompactionChunk)
+ if (!_internal_has_newcompactionchunk()) {
+ clear_data();
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.newcompactionchunk_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ if (!_internal_has_newcompactionchunk()) {
+ clear_data();
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.newcompactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline void CreateNewBackupRequest::set_newcompactionchunk(const void* value,
+ size_t size) {
+ if (!_internal_has_newcompactionchunk()) {
+ clear_data();
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.newcompactionchunk_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+inline std::string* CreateNewBackupRequest::_internal_mutable_newcompactionchunk() {
+ if (!_internal_has_newcompactionchunk()) {
+ clear_data();
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.newcompactionchunk_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* CreateNewBackupRequest::release_newcompactionchunk() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupRequest.newCompactionChunk)
+ if (_internal_has_newcompactionchunk()) {
+ clear_has_data();
+ return data_.newcompactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ } else {
+ return nullptr;
+ }
+}
+inline void CreateNewBackupRequest::set_allocated_newcompactionchunk(std::string* newcompactionchunk) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (newcompactionchunk != nullptr) {
+ set_has_newcompactionchunk();
+ data_.newcompactionchunk_.UnsafeSetDefault(newcompactionchunk);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(newcompactionchunk);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.newCompactionChunk)
+}
+
+inline bool CreateNewBackupRequest::has_data() const {
+ return data_case() != DATA_NOT_SET;
+}
+inline void CreateNewBackupRequest::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+inline CreateNewBackupRequest::DataCase CreateNewBackupRequest::data_case() const {
+ return CreateNewBackupRequest::DataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// CreateNewBackupResponse
+
+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+inline bool CreateNewBackupResponse::_internal_has_authenticationresponsedata() const {
+ return data_case() == kAuthenticationResponseData;
+}
+inline bool CreateNewBackupResponse::has_authenticationresponsedata() const {
+ return _internal_has_authenticationresponsedata();
+}
+inline void CreateNewBackupResponse::set_has_authenticationresponsedata() {
+ _oneof_case_[0] = kAuthenticationResponseData;
+}
+inline void CreateNewBackupResponse::clear_authenticationresponsedata() {
+ if (_internal_has_authenticationresponsedata()) {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationresponsedata_;
+ }
+ clear_has_data();
+ }
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::release_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.authenticationResponseData)
+ if (_internal_has_authenticationresponsedata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.authenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::_internal_authenticationresponsedata() const {
+ return _internal_has_authenticationresponsedata()
+ ? *data_.authenticationresponsedata_
+ : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
+}
+inline const ::backup::FullAuthenticationResponseData& CreateNewBackupResponse::authenticationresponsedata() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.authenticationResponseData)
+ return _internal_authenticationresponsedata();
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::unsafe_arena_release_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.CreateNewBackupResponse.authenticationResponseData)
+ if (_internal_has_authenticationresponsedata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+ data_.authenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void CreateNewBackupResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+ clear_data();
+ if (authenticationresponsedata) {
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = authenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::_internal_mutable_authenticationresponsedata() {
+ if (!_internal_has_authenticationresponsedata()) {
+ clear_data();
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
+ }
+ return data_.authenticationresponsedata_;
+}
+inline ::backup::FullAuthenticationResponseData* CreateNewBackupResponse::mutable_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.authenticationResponseData)
+ return _internal_mutable_authenticationresponsedata();
+}
+
+// bool entropyValid = 2;
+inline bool CreateNewBackupResponse::_internal_has_entropyvalid() const {
+ return data_case() == kEntropyValid;
+}
+inline bool CreateNewBackupResponse::has_entropyvalid() const {
+ return _internal_has_entropyvalid();
+}
+inline void CreateNewBackupResponse::set_has_entropyvalid() {
+ _oneof_case_[0] = kEntropyValid;
+}
+inline void CreateNewBackupResponse::clear_entropyvalid() {
+ if (_internal_has_entropyvalid()) {
+ data_.entropyvalid_ = false;
+ clear_has_data();
+ }
+}
+inline bool CreateNewBackupResponse::_internal_entropyvalid() const {
+ if (_internal_has_entropyvalid()) {
+ return data_.entropyvalid_;
+ }
+ return false;
+}
+inline void CreateNewBackupResponse::_internal_set_entropyvalid(bool value) {
+ if (!_internal_has_entropyvalid()) {
+ clear_data();
+ set_has_entropyvalid();
+ }
+ data_.entropyvalid_ = value;
+}
+inline bool CreateNewBackupResponse::entropyvalid() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.entropyValid)
+ return _internal_entropyvalid();
+}
+inline void CreateNewBackupResponse::set_entropyvalid(bool value) {
+ _internal_set_entropyvalid(value);
+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.entropyValid)
+}
+
+// string backupID = 3;
+inline bool CreateNewBackupResponse::_internal_has_backupid() const {
+ return data_case() == kBackupID;
+}
+inline bool CreateNewBackupResponse::has_backupid() const {
+ return _internal_has_backupid();
+}
+inline void CreateNewBackupResponse::set_has_backupid() {
+ _oneof_case_[0] = kBackupID;
+}
+inline void CreateNewBackupResponse::clear_backupid() {
+ if (_internal_has_backupid()) {
+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
+}
+inline const std::string& CreateNewBackupResponse::backupid() const {
+ // @@protoc_insertion_point(field_get:backup.CreateNewBackupResponse.backupID)
+ return _internal_backupid();
+}
+inline void CreateNewBackupResponse::set_backupid(const std::string& value) {
+ _internal_set_backupid(value);
+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
+}
+inline std::string* CreateNewBackupResponse::mutable_backupid() {
+ // @@protoc_insertion_point(field_mutable:backup.CreateNewBackupResponse.backupID)
+ return _internal_mutable_backupid();
+}
+inline const std::string& CreateNewBackupResponse::_internal_backupid() const {
+ if (_internal_has_backupid()) {
+ return data_.backupid_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void CreateNewBackupResponse::_internal_set_backupid(const std::string& value) {
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void ResetKeyRequest::set_compactionchunk(std::string&& value) {
- // @@protoc_insertion_point(field_set:backup.ResetKeyRequest.compactionChunk)
- if (!_internal_has_compactionchunk()) {
+inline void CreateNewBackupResponse::set_backupid(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.CreateNewBackupResponse.backupID)
+ if (!_internal_has_backupid()) {
clear_data();
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.compactionchunk_.Set(
+ data_.backupid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.ResetKeyRequest.compactionChunk)
+ // @@protoc_insertion_point(field_set_rvalue:backup.CreateNewBackupResponse.backupID)
}
-inline void ResetKeyRequest::set_compactionchunk(const char* value) {
+inline void CreateNewBackupResponse::set_backupid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- if (!_internal_has_compactionchunk()) {
+ if (!_internal_has_backupid()) {
clear_data();
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.ResetKeyRequest.compactionChunk)
+ // @@protoc_insertion_point(field_set_char:backup.CreateNewBackupResponse.backupID)
}
-inline void ResetKeyRequest::set_compactionchunk(const void* value,
+inline void CreateNewBackupResponse::set_backupid(const char* value,
size_t size) {
- if (!_internal_has_compactionchunk()) {
+ if (!_internal_has_backupid()) {
clear_data();
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- data_.compactionchunk_.Set(
+ data_.backupid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size),
GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.ResetKeyRequest.compactionChunk)
+ // @@protoc_insertion_point(field_set_pointer:backup.CreateNewBackupResponse.backupID)
}
-inline std::string* ResetKeyRequest::_internal_mutable_compactionchunk() {
- if (!_internal_has_compactionchunk()) {
+inline std::string* CreateNewBackupResponse::_internal_mutable_backupid() {
+ if (!_internal_has_backupid()) {
clear_data();
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
- return data_.compactionchunk_.Mutable(
+ return data_.backupid_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* ResetKeyRequest::release_compactionchunk() {
- // @@protoc_insertion_point(field_release:backup.ResetKeyRequest.compactionChunk)
- if (_internal_has_compactionchunk()) {
+inline std::string* CreateNewBackupResponse::release_backupid() {
+ // @@protoc_insertion_point(field_release:backup.CreateNewBackupResponse.backupID)
+ if (_internal_has_backupid()) {
clear_has_data();
- return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
} else {
return nullptr;
}
}
-inline void ResetKeyRequest::set_allocated_compactionchunk(std::string* compactionchunk) {
+inline void CreateNewBackupResponse::set_allocated_backupid(std::string* backupid) {
if (has_data()) {
clear_data();
}
- if (compactionchunk != nullptr) {
- set_has_compactionchunk();
- data_.compactionchunk_.UnsafeSetDefault(compactionchunk);
+ if (backupid != nullptr) {
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(backupid);
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
if (arena != nullptr) {
- arena->Own(compactionchunk);
+ arena->Own(backupid);
}
}
- // @@protoc_insertion_point(field_set_allocated:backup.ResetKeyRequest.compactionChunk)
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.backupID)
}
-inline bool ResetKeyRequest::has_data() const {
+inline bool CreateNewBackupResponse::has_data() const {
return data_case() != DATA_NOT_SET;
}
-inline void ResetKeyRequest::clear_has_data() {
+inline void CreateNewBackupResponse::clear_has_data() {
_oneof_case_[0] = DATA_NOT_SET;
}
-inline ResetKeyRequest::DataCase ResetKeyRequest::data_case() const {
- return ResetKeyRequest::DataCase(_oneof_case_[0]);
+inline CreateNewBackupResponse::DataCase CreateNewBackupResponse::data_case() const {
+ return CreateNewBackupResponse::DataCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// SendLogRequest
-// string userId = 1;
-inline void SendLogRequest::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& SendLogRequest::userid() const {
- // @@protoc_insertion_point(field_get:backup.SendLogRequest.userId)
- return _internal_userid();
+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
+inline bool SendLogRequest::_internal_has_authenticationdata() const {
+ return this != internal_default_instance() && authenticationdata_ != nullptr;
}
-inline void SendLogRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:backup.SendLogRequest.userId)
+inline bool SendLogRequest::has_authenticationdata() const {
+ return _internal_has_authenticationdata();
}
-inline std::string* SendLogRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.userId)
- return _internal_mutable_userid();
+inline void SendLogRequest::clear_authenticationdata() {
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
}
-inline const std::string& SendLogRequest::_internal_userid() const {
- return userid_.Get();
+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::_internal_authenticationdata() const {
+ const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
+ return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
+ ::backup::_SimpleAuthenticationRequestData_default_instance_);
}
-inline void SendLogRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const ::backup::SimpleAuthenticationRequestData& SendLogRequest::authenticationdata() const {
+ // @@protoc_insertion_point(field_get:backup.SendLogRequest.authenticationData)
+ return _internal_authenticationdata();
}
-inline void SendLogRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.userId)
+inline void SendLogRequest::unsafe_arena_set_allocated_authenticationdata(
+ ::backup::SimpleAuthenticationRequestData* authenticationdata) {
+ if (GetArena() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+ }
+ authenticationdata_ = authenticationdata;
+ if (authenticationdata) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.SendLogRequest.authenticationData)
}
-inline void SendLogRequest::set_userid(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::release_authenticationdata() {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.userId)
+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ return temp;
}
-inline void SendLogRequest::set_userid(const char* value,
- size_t size) {
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::unsafe_arena_release_authenticationdata() {
+ // @@protoc_insertion_point(field_release:backup.SendLogRequest.authenticationData)
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.userId)
+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ return temp;
}
-inline std::string* SendLogRequest::_internal_mutable_userid() {
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::_internal_mutable_authenticationdata() {
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* SendLogRequest::release_userid() {
- // @@protoc_insertion_point(field_release:backup.SendLogRequest.userId)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void SendLogRequest::set_allocated_userid(std::string* userid) {
- if (userid != nullptr) {
+ if (authenticationdata_ == nullptr) {
+ auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
+ authenticationdata_ = p;
+ }
+ return authenticationdata_;
+}
+inline ::backup::SimpleAuthenticationRequestData* SendLogRequest::mutable_authenticationdata() {
+ // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.authenticationData)
+ return _internal_mutable_authenticationdata();
+}
+inline void SendLogRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ if (message_arena == nullptr) {
+ delete authenticationdata_;
+ }
+ if (authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+ if (message_arena != submessage_arena) {
+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationdata, submessage_arena);
+ }
} else {
}
- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.userId)
+ authenticationdata_ = authenticationdata;
+ // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.authenticationData)
}
-// bytes data = 2;
-inline void SendLogRequest::clear_data() {
- data_.ClearToEmpty();
+// bytes logData = 2;
+inline void SendLogRequest::clear_logdata() {
+ logdata_.ClearToEmpty();
}
-inline const std::string& SendLogRequest::data() const {
- // @@protoc_insertion_point(field_get:backup.SendLogRequest.data)
- return _internal_data();
+inline const std::string& SendLogRequest::logdata() const {
+ // @@protoc_insertion_point(field_get:backup.SendLogRequest.logData)
+ return _internal_logdata();
}
-inline void SendLogRequest::set_data(const std::string& value) {
- _internal_set_data(value);
- // @@protoc_insertion_point(field_set:backup.SendLogRequest.data)
+inline void SendLogRequest::set_logdata(const std::string& value) {
+ _internal_set_logdata(value);
+ // @@protoc_insertion_point(field_set:backup.SendLogRequest.logData)
}
-inline std::string* SendLogRequest::mutable_data() {
- // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.data)
- return _internal_mutable_data();
+inline std::string* SendLogRequest::mutable_logdata() {
+ // @@protoc_insertion_point(field_mutable:backup.SendLogRequest.logData)
+ return _internal_mutable_logdata();
}
-inline const std::string& SendLogRequest::_internal_data() const {
- return data_.Get();
+inline const std::string& SendLogRequest::_internal_logdata() const {
+ return logdata_.Get();
}
-inline void SendLogRequest::_internal_set_data(const std::string& value) {
+inline void SendLogRequest::_internal_set_logdata(const std::string& value) {
- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void SendLogRequest::set_data(std::string&& value) {
+inline void SendLogRequest::set_logdata(std::string&& value) {
- data_.Set(
+ logdata_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.data)
+ // @@protoc_insertion_point(field_set_rvalue:backup.SendLogRequest.logData)
}
-inline void SendLogRequest::set_data(const char* value) {
+inline void SendLogRequest::set_logdata(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.data)
+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.SendLogRequest.logData)
}
-inline void SendLogRequest::set_data(const void* value,
+inline void SendLogRequest::set_logdata(const void* value,
size_t size) {
- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.data)
+ // @@protoc_insertion_point(field_set_pointer:backup.SendLogRequest.logData)
}
-inline std::string* SendLogRequest::_internal_mutable_data() {
+inline std::string* SendLogRequest::_internal_mutable_logdata() {
- return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return logdata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* SendLogRequest::release_data() {
- // @@protoc_insertion_point(field_release:backup.SendLogRequest.data)
- return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendLogRequest::release_logdata() {
+ // @@protoc_insertion_point(field_release:backup.SendLogRequest.logData)
+ return logdata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void SendLogRequest::set_allocated_data(std::string* data) {
- if (data != nullptr) {
+inline void SendLogRequest::set_allocated_logdata(std::string* logdata) {
+ if (logdata != nullptr) {
} else {
}
- data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
+ logdata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), logdata,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.data)
+ // @@protoc_insertion_point(field_set_allocated:backup.SendLogRequest.logData)
}
// -------------------------------------------------------------------
-// PullBackupKeyRequest
+// RecoverBackupKeyRequest
-// string userId = 1;
-inline void PullBackupKeyRequest::clear_userid() {
- userid_.ClearToEmpty();
+// .backup.FullAuthenticationRequestData authenticationData = 1;
+inline bool RecoverBackupKeyRequest::_internal_has_authenticationdata() const {
+ return this != internal_default_instance() && authenticationdata_ != nullptr;
}
-inline const std::string& PullBackupKeyRequest::userid() const {
- // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.userId)
- return _internal_userid();
-}
-inline void PullBackupKeyRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.userId)
+inline bool RecoverBackupKeyRequest::has_authenticationdata() const {
+ return _internal_has_authenticationdata();
}
-inline std::string* PullBackupKeyRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.userId)
- return _internal_mutable_userid();
+inline void RecoverBackupKeyRequest::clear_authenticationdata() {
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
}
-inline const std::string& PullBackupKeyRequest::_internal_userid() const {
- return userid_.Get();
+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::_internal_authenticationdata() const {
+ const ::backup::FullAuthenticationRequestData* p = authenticationdata_;
+ return p != nullptr ? *p : reinterpret_cast<const ::backup::FullAuthenticationRequestData&>(
+ ::backup::_FullAuthenticationRequestData_default_instance_);
}
-inline void PullBackupKeyRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const ::backup::FullAuthenticationRequestData& RecoverBackupKeyRequest::authenticationdata() const {
+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyRequest.authenticationData)
+ return _internal_authenticationdata();
}
-inline void PullBackupKeyRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.userId)
+inline void RecoverBackupKeyRequest::unsafe_arena_set_allocated_authenticationdata(
+ ::backup::FullAuthenticationRequestData* authenticationdata) {
+ if (GetArena() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+ }
+ authenticationdata_ = authenticationdata;
+ if (authenticationdata) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
}
-inline void PullBackupKeyRequest::set_userid(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::release_authenticationdata() {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.userId)
+ ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ return temp;
}
-inline void PullBackupKeyRequest::set_userid(const char* value,
- size_t size) {
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::unsafe_arena_release_authenticationdata() {
+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyRequest.authenticationData)
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.userId)
+ ::backup::FullAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ return temp;
}
-inline std::string* PullBackupKeyRequest::_internal_mutable_userid() {
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::_internal_mutable_authenticationdata() {
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PullBackupKeyRequest::release_userid() {
- // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.userId)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PullBackupKeyRequest::set_allocated_userid(std::string* userid) {
- if (userid != nullptr) {
+ if (authenticationdata_ == nullptr) {
+ auto* p = CreateMaybeMessage<::backup::FullAuthenticationRequestData>(GetArena());
+ authenticationdata_ = p;
+ }
+ return authenticationdata_;
+}
+inline ::backup::FullAuthenticationRequestData* RecoverBackupKeyRequest::mutable_authenticationdata() {
+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyRequest.authenticationData)
+ return _internal_mutable_authenticationdata();
+}
+inline void RecoverBackupKeyRequest::set_allocated_authenticationdata(::backup::FullAuthenticationRequestData* authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ if (message_arena == nullptr) {
+ delete authenticationdata_;
+ }
+ if (authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+ if (message_arena != submessage_arena) {
+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationdata, submessage_arena);
+ }
} else {
}
- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.userId)
+ authenticationdata_ = authenticationdata;
+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyRequest.authenticationData)
}
-// bytes pakeKey = 2;
-inline void PullBackupKeyRequest::clear_pakekey() {
- pakekey_.ClearToEmpty();
-}
-inline const std::string& PullBackupKeyRequest::pakekey() const {
- // @@protoc_insertion_point(field_get:backup.PullBackupKeyRequest.pakeKey)
- return _internal_pakekey();
-}
-inline void PullBackupKeyRequest::set_pakekey(const std::string& value) {
- _internal_set_pakekey(value);
- // @@protoc_insertion_point(field_set:backup.PullBackupKeyRequest.pakeKey)
-}
-inline std::string* PullBackupKeyRequest::mutable_pakekey() {
- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyRequest.pakeKey)
- return _internal_mutable_pakekey();
-}
-inline const std::string& PullBackupKeyRequest::_internal_pakekey() const {
- return pakekey_.Get();
+// -------------------------------------------------------------------
+
+// RecoverBackupKeyResponse
+
+// .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+inline bool RecoverBackupKeyResponse::_internal_has_authenticationresponsedata() const {
+ return data_case() == kAuthenticationResponseData;
}
-inline void PullBackupKeyRequest::_internal_set_pakekey(const std::string& value) {
-
- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline bool RecoverBackupKeyResponse::has_authenticationresponsedata() const {
+ return _internal_has_authenticationresponsedata();
}
-inline void PullBackupKeyRequest::set_pakekey(std::string&& value) {
-
- pakekey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyRequest.pakeKey)
+inline void RecoverBackupKeyResponse::set_has_authenticationresponsedata() {
+ _oneof_case_[0] = kAuthenticationResponseData;
}
-inline void PullBackupKeyRequest::set_pakekey(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyRequest.pakeKey)
+inline void RecoverBackupKeyResponse::clear_authenticationresponsedata() {
+ if (_internal_has_authenticationresponsedata()) {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationresponsedata_;
+ }
+ clear_has_data();
+ }
}
-inline void PullBackupKeyRequest::set_pakekey(const void* value,
- size_t size) {
-
- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyRequest.pakeKey)
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::release_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
+ if (_internal_has_authenticationresponsedata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.authenticationresponsedata_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
}
-inline std::string* PullBackupKeyRequest::_internal_mutable_pakekey() {
-
- return pakekey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::_internal_authenticationresponsedata() const {
+ return _internal_has_authenticationresponsedata()
+ ? *data_.authenticationresponsedata_
+ : reinterpret_cast< ::backup::FullAuthenticationResponseData&>(::backup::_FullAuthenticationResponseData_default_instance_);
}
-inline std::string* PullBackupKeyRequest::release_pakekey() {
- // @@protoc_insertion_point(field_release:backup.PullBackupKeyRequest.pakeKey)
- return pakekey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline const ::backup::FullAuthenticationResponseData& RecoverBackupKeyResponse::authenticationresponsedata() const {
+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.authenticationResponseData)
+ return _internal_authenticationresponsedata();
}
-inline void PullBackupKeyRequest::set_allocated_pakekey(std::string* pakekey) {
- if (pakekey != nullptr) {
-
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::unsafe_arena_release_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.authenticationResponseData)
+ if (_internal_has_authenticationresponsedata()) {
+ clear_has_data();
+ ::backup::FullAuthenticationResponseData* temp = data_.authenticationresponsedata_;
+ data_.authenticationresponsedata_ = nullptr;
+ return temp;
} else {
-
+ return nullptr;
}
- pakekey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakekey,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyRequest.pakeKey)
-}
-
-// -------------------------------------------------------------------
-
-// PullBackupKeyResponse
-
-// bytes encryptedBackupKey = 1;
-inline void PullBackupKeyResponse::clear_encryptedbackupkey() {
- encryptedbackupkey_.ClearToEmpty();
}
-inline const std::string& PullBackupKeyResponse::encryptedbackupkey() const {
- // @@protoc_insertion_point(field_get:backup.PullBackupKeyResponse.encryptedBackupKey)
- return _internal_encryptedbackupkey();
+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+ clear_data();
+ if (authenticationresponsedata) {
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = authenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
}
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const std::string& value) {
- _internal_set_encryptedbackupkey(value);
- // @@protoc_insertion_point(field_set:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::_internal_mutable_authenticationresponsedata() {
+ if (!_internal_has_authenticationresponsedata()) {
+ clear_data();
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(GetArena());
+ }
+ return data_.authenticationresponsedata_;
}
-inline std::string* PullBackupKeyResponse::mutable_encryptedbackupkey() {
- // @@protoc_insertion_point(field_mutable:backup.PullBackupKeyResponse.encryptedBackupKey)
- return _internal_mutable_encryptedbackupkey();
+inline ::backup::FullAuthenticationResponseData* RecoverBackupKeyResponse::mutable_authenticationresponsedata() {
+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.authenticationResponseData)
+ return _internal_mutable_authenticationresponsedata();
}
-inline const std::string& PullBackupKeyResponse::_internal_encryptedbackupkey() const {
- return encryptedbackupkey_.Get();
+
+// .backup.BackupKeyEntropy backupKeyEntropy = 2;
+inline bool RecoverBackupKeyResponse::_internal_has_backupkeyentropy() const {
+ return data_case() == kBackupKeyEntropy;
}
-inline void PullBackupKeyResponse::_internal_set_encryptedbackupkey(const std::string& value) {
-
- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline bool RecoverBackupKeyResponse::has_backupkeyentropy() const {
+ return _internal_has_backupkeyentropy();
}
-inline void PullBackupKeyResponse::set_encryptedbackupkey(std::string&& value) {
-
- encryptedbackupkey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline void RecoverBackupKeyResponse::set_has_backupkeyentropy() {
+ _oneof_case_[0] = kBackupKeyEntropy;
}
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline void RecoverBackupKeyResponse::clear_backupkeyentropy() {
+ if (_internal_has_backupkeyentropy()) {
+ if (GetArena() == nullptr) {
+ delete data_.backupkeyentropy_;
+ }
+ clear_has_data();
+ }
}
-inline void PullBackupKeyResponse::set_encryptedbackupkey(const void* value,
- size_t size) {
-
- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullBackupKeyResponse.encryptedBackupKey)
+inline ::backup::BackupKeyEntropy* RecoverBackupKeyResponse::release_backupkeyentropy() {
+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+ if (_internal_has_backupkeyentropy()) {
+ clear_has_data();
+ ::backup::BackupKeyEntropy* temp = data_.backupkeyentropy_;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ data_.backupkeyentropy_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
}
-inline std::string* PullBackupKeyResponse::_internal_mutable_encryptedbackupkey() {
-
- return encryptedbackupkey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline const ::backup::BackupKeyEntropy& RecoverBackupKeyResponse::_internal_backupkeyentropy() const {
+ return _internal_has_backupkeyentropy()
+ ? *data_.backupkeyentropy_
+ : reinterpret_cast< ::backup::BackupKeyEntropy&>(::backup::_BackupKeyEntropy_default_instance_);
}
-inline std::string* PullBackupKeyResponse::release_encryptedbackupkey() {
- // @@protoc_insertion_point(field_release:backup.PullBackupKeyResponse.encryptedBackupKey)
- return encryptedbackupkey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline const ::backup::BackupKeyEntropy& RecoverBackupKeyResponse::backupkeyentropy() const {
+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+ return _internal_backupkeyentropy();
}
-inline void PullBackupKeyResponse::set_allocated_encryptedbackupkey(std::string* encryptedbackupkey) {
- if (encryptedbackupkey != nullptr) {
-
+inline ::backup::BackupKeyEntropy* RecoverBackupKeyResponse::unsafe_arena_release_backupkeyentropy() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+ if (_internal_has_backupkeyentropy()) {
+ clear_has_data();
+ ::backup::BackupKeyEntropy* temp = data_.backupkeyentropy_;
+ data_.backupkeyentropy_ = nullptr;
+ return temp;
} else {
-
+ return nullptr;
}
- encryptedbackupkey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryptedbackupkey,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.PullBackupKeyResponse.encryptedBackupKey)
+}
+inline void RecoverBackupKeyResponse::unsafe_arena_set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy) {
+ clear_data();
+ if (backupkeyentropy) {
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = backupkeyentropy;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+}
+inline ::backup::BackupKeyEntropy* RecoverBackupKeyResponse::_internal_mutable_backupkeyentropy() {
+ if (!_internal_has_backupkeyentropy()) {
+ clear_data();
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = CreateMaybeMessage< ::backup::BackupKeyEntropy >(GetArena());
+ }
+ return data_.backupkeyentropy_;
+}
+inline ::backup::BackupKeyEntropy* RecoverBackupKeyResponse::mutable_backupkeyentropy() {
+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+ return _internal_mutable_backupkeyentropy();
}
-// -------------------------------------------------------------------
-
-// PullCompactionRequest
-
-// string userId = 1;
-inline void PullCompactionRequest::clear_userid() {
- userid_.ClearToEmpty();
+// string backupID = 4;
+inline bool RecoverBackupKeyResponse::_internal_has_backupid() const {
+ return data_case() == kBackupID;
}
-inline const std::string& PullCompactionRequest::userid() const {
- // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.userId)
- return _internal_userid();
+inline bool RecoverBackupKeyResponse::has_backupid() const {
+ return _internal_has_backupid();
}
-inline void PullCompactionRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.userId)
+inline void RecoverBackupKeyResponse::set_has_backupid() {
+ _oneof_case_[0] = kBackupID;
}
-inline std::string* PullCompactionRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.userId)
- return _internal_mutable_userid();
+inline void RecoverBackupKeyResponse::clear_backupid() {
+ if (_internal_has_backupid()) {
+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ clear_has_data();
+ }
}
-inline const std::string& PullCompactionRequest::_internal_userid() const {
- return userid_.Get();
+inline const std::string& RecoverBackupKeyResponse::backupid() const {
+ // @@protoc_insertion_point(field_get:backup.RecoverBackupKeyResponse.backupID)
+ return _internal_backupid();
}
-inline void PullCompactionRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline void RecoverBackupKeyResponse::set_backupid(const std::string& value) {
+ _internal_set_backupid(value);
+ // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
}
-inline void PullCompactionRequest::set_userid(std::string&& value) {
-
- userid_.Set(
+inline std::string* RecoverBackupKeyResponse::mutable_backupid() {
+ // @@protoc_insertion_point(field_mutable:backup.RecoverBackupKeyResponse.backupID)
+ return _internal_mutable_backupid();
+}
+inline const std::string& RecoverBackupKeyResponse::_internal_backupid() const {
+ if (_internal_has_backupid()) {
+ return data_.backupid_.Get();
+ }
+ return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void RecoverBackupKeyResponse::_internal_set_backupid(const std::string& value) {
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void RecoverBackupKeyResponse::set_backupid(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.RecoverBackupKeyResponse.backupID)
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.backupid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.userId)
+ // @@protoc_insertion_point(field_set_rvalue:backup.RecoverBackupKeyResponse.backupID)
}
-inline void PullCompactionRequest::set_userid(const char* value) {
+inline void RecoverBackupKeyResponse::set_backupid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.userId)
-}
-inline void PullCompactionRequest::set_userid(const char* value,
- size_t size) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.userId)
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
+ ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:backup.RecoverBackupKeyResponse.backupID)
}
-inline std::string* PullCompactionRequest::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void RecoverBackupKeyResponse::set_backupid(const char* value,
+ size_t size) {
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ data_.backupid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size),
+ GetArena());
+ // @@protoc_insertion_point(field_set_pointer:backup.RecoverBackupKeyResponse.backupID)
}
-inline std::string* PullCompactionRequest::release_userid() {
- // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.userId)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* RecoverBackupKeyResponse::_internal_mutable_backupid() {
+ if (!_internal_has_backupid()) {
+ clear_data();
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ }
+ return data_.backupid_.Mutable(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline void PullCompactionRequest::set_allocated_userid(std::string* userid) {
- if (userid != nullptr) {
-
+inline std::string* RecoverBackupKeyResponse::release_backupid() {
+ // @@protoc_insertion_point(field_release:backup.RecoverBackupKeyResponse.backupID)
+ if (_internal_has_backupid()) {
+ clear_has_data();
+ return data_.backupid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
} else {
-
+ return nullptr;
}
- userid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.userId)
+}
+inline void RecoverBackupKeyResponse::set_allocated_backupid(std::string* backupid) {
+ if (has_data()) {
+ clear_data();
+ }
+ if (backupid != nullptr) {
+ set_has_backupid();
+ data_.backupid_.UnsafeSetDefault(backupid);
+ ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
+ if (arena != nullptr) {
+ arena->Own(backupid);
+ }
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.backupID)
}
-// bytes message = 2;
-inline void PullCompactionRequest::clear_message() {
- message_.ClearToEmpty();
+inline bool RecoverBackupKeyResponse::has_data() const {
+ return data_case() != DATA_NOT_SET;
}
-inline const std::string& PullCompactionRequest::message() const {
- // @@protoc_insertion_point(field_get:backup.PullCompactionRequest.message)
- return _internal_message();
+inline void RecoverBackupKeyResponse::clear_has_data() {
+ _oneof_case_[0] = DATA_NOT_SET;
}
-inline void PullCompactionRequest::set_message(const std::string& value) {
- _internal_set_message(value);
- // @@protoc_insertion_point(field_set:backup.PullCompactionRequest.message)
+inline RecoverBackupKeyResponse::DataCase RecoverBackupKeyResponse::data_case() const {
+ return RecoverBackupKeyResponse::DataCase(_oneof_case_[0]);
}
-inline std::string* PullCompactionRequest::mutable_message() {
- // @@protoc_insertion_point(field_mutable:backup.PullCompactionRequest.message)
- return _internal_mutable_message();
+// -------------------------------------------------------------------
+
+// PullBackupRequest
+
+// .backup.SimpleAuthenticationRequestData authenticationData = 1;
+inline bool PullBackupRequest::_internal_has_authenticationdata() const {
+ return this != internal_default_instance() && authenticationdata_ != nullptr;
}
-inline const std::string& PullCompactionRequest::_internal_message() const {
- return message_.Get();
+inline bool PullBackupRequest::has_authenticationdata() const {
+ return _internal_has_authenticationdata();
}
-inline void PullCompactionRequest::_internal_set_message(const std::string& value) {
-
- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline void PullBackupRequest::clear_authenticationdata() {
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
}
-inline void PullCompactionRequest::set_message(std::string&& value) {
-
- message_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionRequest.message)
+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::_internal_authenticationdata() const {
+ const ::backup::SimpleAuthenticationRequestData* p = authenticationdata_;
+ return p != nullptr ? *p : reinterpret_cast<const ::backup::SimpleAuthenticationRequestData&>(
+ ::backup::_SimpleAuthenticationRequestData_default_instance_);
}
-inline void PullCompactionRequest::set_message(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullCompactionRequest.message)
+inline const ::backup::SimpleAuthenticationRequestData& PullBackupRequest::authenticationdata() const {
+ // @@protoc_insertion_point(field_get:backup.PullBackupRequest.authenticationData)
+ return _internal_authenticationdata();
}
-inline void PullCompactionRequest::set_message(const void* value,
- size_t size) {
-
- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionRequest.message)
+inline void PullBackupRequest::unsafe_arena_set_allocated_authenticationdata(
+ ::backup::SimpleAuthenticationRequestData* authenticationdata) {
+ if (GetArena() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(authenticationdata_);
+ }
+ authenticationdata_ = authenticationdata;
+ if (authenticationdata) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:backup.PullBackupRequest.authenticationData)
}
-inline std::string* PullCompactionRequest::_internal_mutable_message() {
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::release_authenticationdata() {
- return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ if (GetArena() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ return temp;
}
-inline std::string* PullCompactionRequest::release_message() {
- // @@protoc_insertion_point(field_release:backup.PullCompactionRequest.message)
- return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::unsafe_arena_release_authenticationdata() {
+ // @@protoc_insertion_point(field_release:backup.PullBackupRequest.authenticationData)
+
+ ::backup::SimpleAuthenticationRequestData* temp = authenticationdata_;
+ authenticationdata_ = nullptr;
+ return temp;
}
-inline void PullCompactionRequest::set_allocated_message(std::string* message) {
- if (message != nullptr) {
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::_internal_mutable_authenticationdata() {
+
+ if (authenticationdata_ == nullptr) {
+ auto* p = CreateMaybeMessage<::backup::SimpleAuthenticationRequestData>(GetArena());
+ authenticationdata_ = p;
+ }
+ return authenticationdata_;
+}
+inline ::backup::SimpleAuthenticationRequestData* PullBackupRequest::mutable_authenticationdata() {
+ // @@protoc_insertion_point(field_mutable:backup.PullBackupRequest.authenticationData)
+ return _internal_mutable_authenticationdata();
+}
+inline void PullBackupRequest::set_allocated_authenticationdata(::backup::SimpleAuthenticationRequestData* authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ if (message_arena == nullptr) {
+ delete authenticationdata_;
+ }
+ if (authenticationdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationdata);
+ if (message_arena != submessage_arena) {
+ authenticationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationdata, submessage_arena);
+ }
} else {
}
- message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionRequest.message)
+ authenticationdata_ = authenticationdata;
+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupRequest.authenticationData)
}
// -------------------------------------------------------------------
-// PullCompactionResponse
+// PullBackupResponse
// bytes compactionChunk = 1;
-inline bool PullCompactionResponse::_internal_has_compactionchunk() const {
+inline bool PullBackupResponse::_internal_has_compactionchunk() const {
return data_case() == kCompactionChunk;
}
-inline bool PullCompactionResponse::has_compactionchunk() const {
+inline bool PullBackupResponse::has_compactionchunk() const {
return _internal_has_compactionchunk();
}
-inline void PullCompactionResponse::set_has_compactionchunk() {
+inline void PullBackupResponse::set_has_compactionchunk() {
_oneof_case_[0] = kCompactionChunk;
}
-inline void PullCompactionResponse::clear_compactionchunk() {
+inline void PullBackupResponse::clear_compactionchunk() {
if (_internal_has_compactionchunk()) {
data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
clear_has_data();
}
}
-inline const std::string& PullCompactionResponse::compactionchunk() const {
- // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.compactionChunk)
+inline const std::string& PullBackupResponse::compactionchunk() const {
+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.compactionChunk)
return _internal_compactionchunk();
}
-inline void PullCompactionResponse::set_compactionchunk(const std::string& value) {
+inline void PullBackupResponse::set_compactionchunk(const std::string& value) {
_internal_set_compactionchunk(value);
- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
}
-inline std::string* PullCompactionResponse::mutable_compactionchunk() {
- // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.compactionChunk)
+inline std::string* PullBackupResponse::mutable_compactionchunk() {
+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.compactionChunk)
return _internal_mutable_compactionchunk();
}
-inline const std::string& PullCompactionResponse::_internal_compactionchunk() const {
+inline const std::string& PullBackupResponse::_internal_compactionchunk() const {
if (_internal_has_compactionchunk()) {
return data_.compactionchunk_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
-inline void PullCompactionResponse::_internal_set_compactionchunk(const std::string& value) {
+inline void PullBackupResponse::_internal_set_compactionchunk(const std::string& value) {
if (!_internal_has_compactionchunk()) {
clear_data();
set_has_compactionchunk();
@@ -1901,8 +6149,8 @@
}
data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void PullCompactionResponse::set_compactionchunk(std::string&& value) {
- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.compactionChunk)
+inline void PullBackupResponse::set_compactionchunk(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.compactionChunk)
if (!_internal_has_compactionchunk()) {
clear_data();
set_has_compactionchunk();
@@ -1910,9 +6158,9 @@
}
data_.compactionchunk_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.compactionChunk)
+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.compactionChunk)
}
-inline void PullCompactionResponse::set_compactionchunk(const char* value) {
+inline void PullBackupResponse::set_compactionchunk(const char* value) {
GOOGLE_DCHECK(value != nullptr);
if (!_internal_has_compactionchunk()) {
clear_data();
@@ -1921,9 +6169,9 @@
}
data_.compactionchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.compactionChunk)
+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.compactionChunk)
}
-inline void PullCompactionResponse::set_compactionchunk(const void* value,
+inline void PullBackupResponse::set_compactionchunk(const void* value,
size_t size) {
if (!_internal_has_compactionchunk()) {
clear_data();
@@ -1934,9 +6182,9 @@
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size),
GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.compactionChunk)
+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.compactionChunk)
}
-inline std::string* PullCompactionResponse::_internal_mutable_compactionchunk() {
+inline std::string* PullBackupResponse::_internal_mutable_compactionchunk() {
if (!_internal_has_compactionchunk()) {
clear_data();
set_has_compactionchunk();
@@ -1945,8 +6193,8 @@
return data_.compactionchunk_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* PullCompactionResponse::release_compactionchunk() {
- // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.compactionChunk)
+inline std::string* PullBackupResponse::release_compactionchunk() {
+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.compactionChunk)
if (_internal_has_compactionchunk()) {
clear_has_data();
return data_.compactionchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
@@ -1954,7 +6202,7 @@
return nullptr;
}
}
-inline void PullCompactionResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
+inline void PullBackupResponse::set_allocated_compactionchunk(std::string* compactionchunk) {
if (has_data()) {
clear_data();
}
@@ -1966,44 +6214,44 @@
arena->Own(compactionchunk);
}
}
- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.compactionChunk)
+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.compactionChunk)
}
// bytes logChunk = 2;
-inline bool PullCompactionResponse::_internal_has_logchunk() const {
+inline bool PullBackupResponse::_internal_has_logchunk() const {
return data_case() == kLogChunk;
}
-inline bool PullCompactionResponse::has_logchunk() const {
+inline bool PullBackupResponse::has_logchunk() const {
return _internal_has_logchunk();
}
-inline void PullCompactionResponse::set_has_logchunk() {
+inline void PullBackupResponse::set_has_logchunk() {
_oneof_case_[0] = kLogChunk;
}
-inline void PullCompactionResponse::clear_logchunk() {
+inline void PullBackupResponse::clear_logchunk() {
if (_internal_has_logchunk()) {
data_.logchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
clear_has_data();
}
}
-inline const std::string& PullCompactionResponse::logchunk() const {
- // @@protoc_insertion_point(field_get:backup.PullCompactionResponse.logChunk)
+inline const std::string& PullBackupResponse::logchunk() const {
+ // @@protoc_insertion_point(field_get:backup.PullBackupResponse.logChunk)
return _internal_logchunk();
}
-inline void PullCompactionResponse::set_logchunk(const std::string& value) {
+inline void PullBackupResponse::set_logchunk(const std::string& value) {
_internal_set_logchunk(value);
- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
}
-inline std::string* PullCompactionResponse::mutable_logchunk() {
- // @@protoc_insertion_point(field_mutable:backup.PullCompactionResponse.logChunk)
+inline std::string* PullBackupResponse::mutable_logchunk() {
+ // @@protoc_insertion_point(field_mutable:backup.PullBackupResponse.logChunk)
return _internal_mutable_logchunk();
}
-inline const std::string& PullCompactionResponse::_internal_logchunk() const {
+inline const std::string& PullBackupResponse::_internal_logchunk() const {
if (_internal_has_logchunk()) {
return data_.logchunk_.Get();
}
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
-inline void PullCompactionResponse::_internal_set_logchunk(const std::string& value) {
+inline void PullBackupResponse::_internal_set_logchunk(const std::string& value) {
if (!_internal_has_logchunk()) {
clear_data();
set_has_logchunk();
@@ -2011,8 +6259,8 @@
}
data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void PullCompactionResponse::set_logchunk(std::string&& value) {
- // @@protoc_insertion_point(field_set:backup.PullCompactionResponse.logChunk)
+inline void PullBackupResponse::set_logchunk(std::string&& value) {
+ // @@protoc_insertion_point(field_set:backup.PullBackupResponse.logChunk)
if (!_internal_has_logchunk()) {
clear_data();
set_has_logchunk();
@@ -2020,9 +6268,9 @@
}
data_.logchunk_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:backup.PullCompactionResponse.logChunk)
+ // @@protoc_insertion_point(field_set_rvalue:backup.PullBackupResponse.logChunk)
}
-inline void PullCompactionResponse::set_logchunk(const char* value) {
+inline void PullBackupResponse::set_logchunk(const char* value) {
GOOGLE_DCHECK(value != nullptr);
if (!_internal_has_logchunk()) {
clear_data();
@@ -2031,9 +6279,9 @@
}
data_.logchunk_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:backup.PullCompactionResponse.logChunk)
+ // @@protoc_insertion_point(field_set_char:backup.PullBackupResponse.logChunk)
}
-inline void PullCompactionResponse::set_logchunk(const void* value,
+inline void PullBackupResponse::set_logchunk(const void* value,
size_t size) {
if (!_internal_has_logchunk()) {
clear_data();
@@ -2044,9 +6292,9 @@
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size),
GetArena());
- // @@protoc_insertion_point(field_set_pointer:backup.PullCompactionResponse.logChunk)
+ // @@protoc_insertion_point(field_set_pointer:backup.PullBackupResponse.logChunk)
}
-inline std::string* PullCompactionResponse::_internal_mutable_logchunk() {
+inline std::string* PullBackupResponse::_internal_mutable_logchunk() {
if (!_internal_has_logchunk()) {
clear_data();
set_has_logchunk();
@@ -2055,8 +6303,8 @@
return data_.logchunk_.Mutable(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* PullCompactionResponse::release_logchunk() {
- // @@protoc_insertion_point(field_release:backup.PullCompactionResponse.logChunk)
+inline std::string* PullBackupResponse::release_logchunk() {
+ // @@protoc_insertion_point(field_release:backup.PullBackupResponse.logChunk)
if (_internal_has_logchunk()) {
clear_has_data();
return data_.logchunk_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
@@ -2064,7 +6312,7 @@
return nullptr;
}
}
-inline void PullCompactionResponse::set_allocated_logchunk(std::string* logchunk) {
+inline void PullBackupResponse::set_allocated_logchunk(std::string* logchunk) {
if (has_data()) {
clear_data();
}
@@ -2076,17 +6324,17 @@
arena->Own(logchunk);
}
}
- // @@protoc_insertion_point(field_set_allocated:backup.PullCompactionResponse.logChunk)
+ // @@protoc_insertion_point(field_set_allocated:backup.PullBackupResponse.logChunk)
}
-inline bool PullCompactionResponse::has_data() const {
+inline bool PullBackupResponse::has_data() const {
return data_case() != DATA_NOT_SET;
}
-inline void PullCompactionResponse::clear_has_data() {
+inline void PullBackupResponse::clear_has_data() {
_oneof_case_[0] = DATA_NOT_SET;
}
-inline PullCompactionResponse::DataCase PullCompactionResponse::data_case() const {
- return PullCompactionResponse::DataCase(_oneof_case_[0]);
+inline PullBackupResponse::DataCase PullBackupResponse::data_case() const {
+ return PullBackupResponse::DataCase(_oneof_case_[0]);
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
@@ -2101,6 +6349,26 @@
// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
// @@protoc_insertion_point(namespace_scope)
diff --git a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/backup.pb.cc
@@ -17,23 +17,146 @@
PROTOBUF_PRAGMA_INIT_SEG
namespace backup {
-constexpr ResetKeyRequest::ResetKeyRequest(
+constexpr PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , _oneof_case_{}{}
-struct ResetKeyRequestDefaultTypeInternal {
- constexpr ResetKeyRequestDefaultTypeInternal()
+ , pakeregistrationrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct PakeRegistrationRequestAndUserIDDefaultTypeInternal {
+ constexpr PakeRegistrationRequestAndUserIDDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~ResetKeyRequestDefaultTypeInternal() {}
+ ~PakeRegistrationRequestAndUserIDDefaultTypeInternal() {}
union {
- ResetKeyRequest _instance;
+ PakeRegistrationRequestAndUserID _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetKeyRequestDefaultTypeInternal _ResetKeyRequest_default_instance_;
-constexpr SendLogRequest::SendLogRequest(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
+constexpr PakeAuthenticationRequestData::PakeAuthenticationRequestData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct PakeAuthenticationRequestDataDefaultTypeInternal {
+ constexpr PakeAuthenticationRequestDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~PakeAuthenticationRequestDataDefaultTypeInternal() {}
+ union {
+ PakeAuthenticationRequestData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeAuthenticationRequestDataDefaultTypeInternal _PakeAuthenticationRequestData_default_instance_;
+constexpr WalletAuthenticationRequestData::WalletAuthenticationRequestData(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+ , walletaddress_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , signedmessage_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct WalletAuthenticationRequestDataDefaultTypeInternal {
+ constexpr WalletAuthenticationRequestDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~WalletAuthenticationRequestDataDefaultTypeInternal() {}
+ union {
+ WalletAuthenticationRequestData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletAuthenticationRequestDataDefaultTypeInternal _WalletAuthenticationRequestData_default_instance_;
+constexpr FullAuthenticationRequestData::FullAuthenticationRequestData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct FullAuthenticationRequestDataDefaultTypeInternal {
+ constexpr FullAuthenticationRequestDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~FullAuthenticationRequestDataDefaultTypeInternal() {}
+ union {
+ FullAuthenticationRequestData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationRequestDataDefaultTypeInternal _FullAuthenticationRequestData_default_instance_;
+constexpr WalletAuthenticationResponseData::WalletAuthenticationResponseData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : success_(false){}
+struct WalletAuthenticationResponseDataDefaultTypeInternal {
+ constexpr WalletAuthenticationResponseDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~WalletAuthenticationResponseDataDefaultTypeInternal() {}
+ union {
+ WalletAuthenticationResponseData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletAuthenticationResponseDataDefaultTypeInternal _WalletAuthenticationResponseData_default_instance_;
+constexpr PakeAuthenticationResponseData::PakeAuthenticationResponseData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct PakeAuthenticationResponseDataDefaultTypeInternal {
+ constexpr PakeAuthenticationResponseDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~PakeAuthenticationResponseDataDefaultTypeInternal() {}
+ union {
+ PakeAuthenticationResponseData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeAuthenticationResponseDataDefaultTypeInternal _PakeAuthenticationResponseData_default_instance_;
+constexpr FullAuthenticationResponseData::FullAuthenticationResponseData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct FullAuthenticationResponseDataDefaultTypeInternal {
+ constexpr FullAuthenticationResponseDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~FullAuthenticationResponseDataDefaultTypeInternal() {}
+ union {
+ FullAuthenticationResponseData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FullAuthenticationResponseDataDefaultTypeInternal _FullAuthenticationResponseData_default_instance_;
+constexpr SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : backupid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct SimpleAuthenticationRequestDataDefaultTypeInternal {
+ constexpr SimpleAuthenticationRequestDataDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~SimpleAuthenticationRequestDataDefaultTypeInternal() {}
+ union {
+ SimpleAuthenticationRequestData _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleAuthenticationRequestDataDefaultTypeInternal _SimpleAuthenticationRequestData_default_instance_;
+constexpr BackupKeyEntropy::BackupKeyEntropy(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct BackupKeyEntropyDefaultTypeInternal {
+ constexpr BackupKeyEntropyDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~BackupKeyEntropyDefaultTypeInternal() {}
+ union {
+ BackupKeyEntropy _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BackupKeyEntropyDefaultTypeInternal _BackupKeyEntropy_default_instance_;
+constexpr CreateNewBackupRequest::CreateNewBackupRequest(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct CreateNewBackupRequestDefaultTypeInternal {
+ constexpr CreateNewBackupRequestDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~CreateNewBackupRequestDefaultTypeInternal() {}
+ union {
+ CreateNewBackupRequest _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupRequestDefaultTypeInternal _CreateNewBackupRequest_default_instance_;
+constexpr CreateNewBackupResponse::CreateNewBackupResponse(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct CreateNewBackupResponseDefaultTypeInternal {
+ constexpr CreateNewBackupResponseDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~CreateNewBackupResponseDefaultTypeInternal() {}
+ union {
+ CreateNewBackupResponse _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CreateNewBackupResponseDefaultTypeInternal _CreateNewBackupResponse_default_instance_;
+constexpr SendLogRequest::SendLogRequest(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : logdata_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , authenticationdata_(nullptr){}
struct SendLogRequestDefaultTypeInternal {
constexpr SendLogRequestDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -43,153 +166,299 @@
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendLogRequestDefaultTypeInternal _SendLogRequest_default_instance_;
-constexpr PullBackupKeyRequest::PullBackupKeyRequest(
+constexpr RecoverBackupKeyRequest::RecoverBackupKeyRequest(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , pakekey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullBackupKeyRequestDefaultTypeInternal {
- constexpr PullBackupKeyRequestDefaultTypeInternal()
+ : authenticationdata_(nullptr){}
+struct RecoverBackupKeyRequestDefaultTypeInternal {
+ constexpr RecoverBackupKeyRequestDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PullBackupKeyRequestDefaultTypeInternal() {}
+ ~RecoverBackupKeyRequestDefaultTypeInternal() {}
union {
- PullBackupKeyRequest _instance;
+ RecoverBackupKeyRequest _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyRequestDefaultTypeInternal _PullBackupKeyRequest_default_instance_;
-constexpr PullBackupKeyResponse::PullBackupKeyResponse(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyRequestDefaultTypeInternal _RecoverBackupKeyRequest_default_instance_;
+constexpr RecoverBackupKeyResponse::RecoverBackupKeyResponse(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : encryptedbackupkey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullBackupKeyResponseDefaultTypeInternal {
- constexpr PullBackupKeyResponseDefaultTypeInternal()
+ : _oneof_case_{}{}
+struct RecoverBackupKeyResponseDefaultTypeInternal {
+ constexpr RecoverBackupKeyResponseDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PullBackupKeyResponseDefaultTypeInternal() {}
+ ~RecoverBackupKeyResponseDefaultTypeInternal() {}
union {
- PullBackupKeyResponse _instance;
+ RecoverBackupKeyResponse _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupKeyResponseDefaultTypeInternal _PullBackupKeyResponse_default_instance_;
-constexpr PullCompactionRequest::PullCompactionRequest(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RecoverBackupKeyResponseDefaultTypeInternal _RecoverBackupKeyResponse_default_instance_;
+constexpr PullBackupRequest::PullBackupRequest(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PullCompactionRequestDefaultTypeInternal {
- constexpr PullCompactionRequestDefaultTypeInternal()
+ : authenticationdata_(nullptr){}
+struct PullBackupRequestDefaultTypeInternal {
+ constexpr PullBackupRequestDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PullCompactionRequestDefaultTypeInternal() {}
+ ~PullBackupRequestDefaultTypeInternal() {}
union {
- PullCompactionRequest _instance;
+ PullBackupRequest _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionRequestDefaultTypeInternal _PullCompactionRequest_default_instance_;
-constexpr PullCompactionResponse::PullCompactionResponse(
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupRequestDefaultTypeInternal _PullBackupRequest_default_instance_;
+constexpr PullBackupResponse::PullBackupResponse(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: _oneof_case_{}{}
-struct PullCompactionResponseDefaultTypeInternal {
- constexpr PullCompactionResponseDefaultTypeInternal()
+struct PullBackupResponseDefaultTypeInternal {
+ constexpr PullBackupResponseDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PullCompactionResponseDefaultTypeInternal() {}
+ ~PullBackupResponseDefaultTypeInternal() {}
union {
- PullCompactionResponse _instance;
+ PullBackupResponse _instance;
};
};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullCompactionResponseDefaultTypeInternal _PullCompactionResponse_default_instance_;
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PullBackupResponseDefaultTypeInternal _PullBackupResponse_default_instance_;
} // namespace backup
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[6];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_backup_2eproto[16];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_backup_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_backup_2eproto = nullptr;
const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_backup_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::PakeRegistrationRequestAndUserID, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::backup::PakeRegistrationRequestAndUserID, userid_),
+ PROTOBUF_FIELD_OFFSET(::backup::PakeRegistrationRequestAndUserID, pakeregistrationrequest_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationRequestData, _internal_metadata_),
~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, _oneof_case_[0]),
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationRequestData, _oneof_case_[0]),
~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, userid_),
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::backup::ResetKeyRequest, data_),
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationRequestData, data_),
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationRequestData, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationRequestData, userid_),
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationRequestData, walletaddress_),
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationRequestData, signedmessage_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationRequestData, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationResponseData, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::backup::WalletAuthenticationResponseData, success_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationResponseData, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationResponseData, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::PakeAuthenticationResponseData, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::FullAuthenticationResponseData, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, data_),
+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, backupid_),
+ PROTOBUF_FIELD_OFFSET(::backup::SimpleAuthenticationRequestData, userid_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::BackupKeyEntropy, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::BackupKeyEntropy, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::BackupKeyEntropy, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupRequest, data_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::CreateNewBackupResponse, data_),
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyRequest, pakekey_),
+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, authenticationdata_),
+ PROTOBUF_FIELD_OFFSET(::backup::SendLogRequest, logdata_),
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::backup::PullBackupKeyResponse, encryptedbackupkey_),
+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyRequest, authenticationdata_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::backup::RecoverBackupKeyResponse, data_),
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionRequest, message_),
+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupRequest, authenticationdata_),
~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _internal_metadata_),
+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _internal_metadata_),
~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, _oneof_case_[0]),
+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, _oneof_case_[0]),
~0u, // no _weak_field_map_
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::backup::PullCompactionResponse, data_),
+ PROTOBUF_FIELD_OFFSET(::backup::PullBackupResponse, data_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- { 0, -1, sizeof(::backup::ResetKeyRequest)},
- { 9, -1, sizeof(::backup::SendLogRequest)},
- { 16, -1, sizeof(::backup::PullBackupKeyRequest)},
- { 23, -1, sizeof(::backup::PullBackupKeyResponse)},
- { 29, -1, sizeof(::backup::PullCompactionRequest)},
- { 36, -1, sizeof(::backup::PullCompactionResponse)},
+ { 0, -1, sizeof(::backup::PakeRegistrationRequestAndUserID)},
+ { 7, -1, sizeof(::backup::PakeAuthenticationRequestData)},
+ { 18, -1, sizeof(::backup::WalletAuthenticationRequestData)},
+ { 26, -1, sizeof(::backup::FullAuthenticationRequestData)},
+ { 34, -1, sizeof(::backup::WalletAuthenticationResponseData)},
+ { 40, -1, sizeof(::backup::PakeAuthenticationResponseData)},
+ { 50, -1, sizeof(::backup::FullAuthenticationResponseData)},
+ { 58, -1, sizeof(::backup::SimpleAuthenticationRequestData)},
+ { 65, -1, sizeof(::backup::BackupKeyEntropy)},
+ { 73, -1, sizeof(::backup::CreateNewBackupRequest)},
+ { 82, -1, sizeof(::backup::CreateNewBackupResponse)},
+ { 91, -1, sizeof(::backup::SendLogRequest)},
+ { 98, -1, sizeof(::backup::RecoverBackupKeyRequest)},
+ { 104, -1, sizeof(::backup::RecoverBackupKeyResponse)},
+ { 113, -1, sizeof(::backup::PullBackupRequest)},
+ { 119, -1, sizeof(::backup::PullBackupResponse)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_ResetKeyRequest_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PakeRegistrationRequestAndUserID_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PakeAuthenticationRequestData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_WalletAuthenticationRequestData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationRequestData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_WalletAuthenticationResponseData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PakeAuthenticationResponseData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_FullAuthenticationResponseData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_SimpleAuthenticationRequestData_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_BackupKeyEntropy_default_instance_),
+ 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::_PullBackupKeyRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullBackupKeyResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::backup::_PullCompactionResponse_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_),
};
const char descriptor_table_protodef_backup_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
"\n\014backup.proto\022\006backup\032\033google/protobuf/"
- "empty.proto\"V\n\017ResetKeyRequest\022\016\n\006userId"
- "\030\001 \001(\t\022\020\n\006newKey\030\002 \001(\014H\000\022\031\n\017compactionCh"
- "unk\030\003 \001(\014H\000B\006\n\004data\".\n\016SendLogRequest\022\016\n"
- "\006userId\030\001 \001(\t\022\014\n\004data\030\002 \001(\014\"7\n\024PullBacku"
- "pKeyRequest\022\016\n\006userId\030\001 \001(\t\022\017\n\007pakeKey\030\002"
- " \001(\014\"3\n\025PullBackupKeyResponse\022\032\n\022encrypt"
- "edBackupKey\030\001 \001(\014\"8\n\025PullCompactionReque"
- "st\022\016\n\006userId\030\001 \001(\t\022\017\n\007message\030\002 \001(\014\"O\n\026P"
- "ullCompactionResponse\022\031\n\017compactionChunk"
- "\030\001 \001(\014H\000\022\022\n\010logChunk\030\002 \001(\014H\000B\006\n\004data2\262\002\n"
- "\rBackupService\022\?\n\010ResetKey\022\027.backup.Rese"
- "tKeyRequest\032\026.google.protobuf.Empty\"\000(\001\022"
- ";\n\007SendLog\022\026.backup.SendLogRequest\032\026.goo"
- "gle.protobuf.Empty\"\000\022N\n\rPullBackupKey\022\034."
- "backup.PullBackupKeyRequest\032\035.backup.Pul"
- "lBackupKeyResponse\"\000\022S\n\016PullCompaction\022\035"
- ".backup.PullCompactionRequest\032\036.backup.P"
- "ullCompactionResponse\"\0000\001b\006proto3"
+ "empty.proto\"S\n PakeRegistrationRequestAn"
+ "dUserID\022\016\n\006userID\030\001 \001(\t\022\037\n\027pakeRegistrat"
+ "ionRequest\030\002 \001(\014\"\377\001\n\035PakeAuthenticationR"
+ "equestData\022T\n pakeRegistrationRequestAnd"
+ "UserID\030\001 \001(\0132(.backup.PakeRegistrationRe"
+ "questAndUserIDH\000\022 \n\026pakeRegistrationUplo"
+ "ad\030\002 \001(\014H\000\022\037\n\025pakeCredentialRequest\030\003 \001("
+ "\014H\000\022$\n\032pakeCredentialFinalization\030\004 \001(\014H"
+ "\000\022\027\n\rpakeClientMAC\030\005 \001(\014H\000B\006\n\004data\"_\n\037Wa"
+ "lletAuthenticationRequestData\022\016\n\006userID\030"
+ "\001 \001(\t\022\025\n\rwalletAddress\030\002 \001(\t\022\025\n\rsignedMe"
+ "ssage\030\003 \001(\014\"\313\001\n\035FullAuthenticationReques"
+ "tData\022N\n\035pakeAuthenticationRequestData\030\001"
+ " \001(\0132%.backup.PakeAuthenticationRequestD"
+ "ataH\000\022R\n\037walletAuthenticationRequestData"
+ "\030\002 \001(\0132\'.backup.WalletAuthenticationRequ"
+ "estDataH\000B\006\n\004data\"3\n WalletAuthenticatio"
+ "nResponseData\022\017\n\007success\030\001 \001(\010\"\252\001\n\036PakeA"
+ "uthenticationResponseData\022\"\n\030pakeRegistr"
+ "ationResponse\030\001 \001(\014H\000\022!\n\027pakeRegistratio"
+ "nSuccess\030\002 \001(\010H\000\022 \n\026pakeCredentialRespon"
+ "se\030\003 \001(\014H\000\022\027\n\rpakeServerMAC\030\004 \001(\014H\000B\006\n\004d"
+ "ata\"\320\001\n\036FullAuthenticationResponseData\022P"
+ "\n\036pakeAuthenticationResponseData\030\001 \001(\0132&"
+ ".backup.PakeAuthenticationResponseDataH\000"
+ "\022T\n walletAuthenticationResponseData\030\002 \001"
+ "(\0132(.backup.WalletAuthenticationResponse"
+ "DataH\000B\006\n\004data\"C\n\037SimpleAuthenticationRe"
+ "questData\022\020\n\010backupID\030\001 \001(\t\022\016\n\006userID\030\002 "
+ "\001(\t\"A\n\020BackupKeyEntropy\022\017\n\005nonce\030\001 \001(\014H\000"
+ "\022\024\n\nrawMessage\030\002 \001(\014H\000B\006\n\004data\"\300\001\n\026Creat"
+ "eNewBackupRequest\022J\n\031authenticationReque"
+ "stData\030\001 \001(\0132%.backup.FullAuthentication"
+ "RequestDataH\000\0224\n\020backupKeyEntropy\030\002 \001(\0132"
+ "\030.backup.BackupKeyEntropyH\000\022\034\n\022newCompac"
+ "tionChunk\030\003 \001(\014H\000B\006\n\004data\"\233\001\n\027CreateNewB"
+ "ackupResponse\022L\n\032authenticationResponseD"
+ "ata\030\001 \001(\0132&.backup.FullAuthenticationRes"
+ "ponseDataH\000\022\026\n\014entropyValid\030\002 \001(\010H\000\022\022\n\010b"
+ "ackupID\030\003 \001(\tH\000B\006\n\004data\"f\n\016SendLogReques"
+ "t\022C\n\022authenticationData\030\001 \001(\0132\'.backup.S"
+ "impleAuthenticationRequestData\022\017\n\007logDat"
+ "a\030\002 \001(\014\"\\\n\027RecoverBackupKeyRequest\022A\n\022au"
+ "thenticationData\030\001 \001(\0132%.backup.FullAuth"
+ "enticationRequestData\"\272\001\n\030RecoverBackupK"
+ "eyResponse\022L\n\032authenticationResponseData"
+ "\030\001 \001(\0132&.backup.FullAuthenticationRespon"
+ "seDataH\000\0224\n\020backupKeyEntropy\030\002 \001(\0132\030.bac"
+ "kup.BackupKeyEntropyH\000\022\022\n\010backupID\030\004 \001(\t"
+ "H\000B\006\n\004data\"X\n\021PullBackupRequest\022C\n\022authe"
+ "nticationData\030\001 \001(\0132\'.backup.SimpleAuthe"
+ "nticationRequestData\"K\n\022PullBackupRespon"
+ "se\022\031\n\017compactionChunk\030\001 \001(\014H\000\022\022\n\010logChun"
+ "k\030\002 \001(\014H\000B\006\n\004data2\320\002\n\rBackupService\022X\n\017C"
+ "reateNewBackup\022\036.backup.CreateNewBackupR"
+ "equest\032\037.backup.CreateNewBackupResponse\""
+ "\000(\0010\001\022=\n\007SendLog\022\026.backup.SendLogRequest"
+ "\032\026.google.protobuf.Empty\"\000(\001\022[\n\020RecoverB"
+ "ackupKey\022\037.backup.RecoverBackupKeyReques"
+ "t\032 .backup.RecoverBackupKeyResponse\"\000(\0010"
+ "\001\022I\n\nPullBackup\022\031.backup.PullBackupReque"
+ "st\032\032.backup.PullBackupResponse\"\000(\0010\001b\006pr"
+ "oto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_backup_2eproto_deps[1] = {
&::descriptor_table_google_2fprotobuf_2fempty_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_backup_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_backup_2eproto = {
- false, false, 753, descriptor_table_protodef_backup_2eproto, "backup.proto",
- &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 6,
+ false, false, 2524, descriptor_table_protodef_backup_2eproto, "backup.proto",
+ &descriptor_table_backup_2eproto_once, descriptor_table_backup_2eproto_deps, 1, 16,
schemas, file_default_instances, TableStruct_backup_2eproto::offsets,
file_level_metadata_backup_2eproto, file_level_enum_descriptors_backup_2eproto, file_level_service_descriptors_backup_2eproto,
};
@@ -205,17 +474,17 @@
// ===================================================================
-class ResetKeyRequest::_Internal {
+class PakeRegistrationRequestAndUserID::_Internal {
public:
};
-ResetKeyRequest::ResetKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(arena_constructor:backup.PakeRegistrationRequestAndUserID)
}
-ResetKeyRequest::ResetKeyRequest(const ResetKeyRequest& from)
+PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(const PakeRegistrationRequestAndUserID& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
@@ -223,61 +492,2941 @@
userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
GetArena());
}
+ pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_pakeregistrationrequest().empty()) {
+ pakeregistrationrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakeregistrationrequest(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.PakeRegistrationRequestAndUserID)
+}
+
+void PakeRegistrationRequestAndUserID::SharedCtor() {
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+PakeRegistrationRequestAndUserID::~PakeRegistrationRequestAndUserID() {
+ // @@protoc_insertion_point(destructor:backup.PakeRegistrationRequestAndUserID)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void PakeRegistrationRequestAndUserID::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ pakeregistrationrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void PakeRegistrationRequestAndUserID::ArenaDtor(void* object) {
+ PakeRegistrationRequestAndUserID* _this = reinterpret_cast< PakeRegistrationRequestAndUserID* >(object);
+ (void)_this;
+}
+void PakeRegistrationRequestAndUserID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void PakeRegistrationRequestAndUserID::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void PakeRegistrationRequestAndUserID::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PakeRegistrationRequestAndUserID)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ userid_.ClearToEmpty();
+ pakeregistrationrequest_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PakeRegistrationRequestAndUserID::_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.PakeRegistrationRequestAndUserID.userID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeRegistrationRequest = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_pakeregistrationrequest();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* PakeRegistrationRequestAndUserID::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.PakeRegistrationRequestAndUserID)
+ ::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.PakeRegistrationRequestAndUserID.userID");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_userid(), target);
+ }
+
+ // bytes pakeRegistrationRequest = 2;
+ if (this->pakeregistrationrequest().size() > 0) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_pakeregistrationrequest(), 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.PakeRegistrationRequestAndUserID)
+ return target;
+}
+
+size_t PakeRegistrationRequestAndUserID::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PakeRegistrationRequestAndUserID)
+ 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());
+ }
+
+ // bytes pakeRegistrationRequest = 2;
+ if (this->pakeregistrationrequest().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakeregistrationrequest());
+ }
+
+ 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 PakeRegistrationRequestAndUserID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PakeRegistrationRequestAndUserID)
+ GOOGLE_DCHECK_NE(&from, this);
+ const PakeRegistrationRequestAndUserID* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeRegistrationRequestAndUserID>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PakeRegistrationRequestAndUserID)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PakeRegistrationRequestAndUserID)
+ MergeFrom(*source);
+ }
+}
+
+void PakeRegistrationRequestAndUserID::MergeFrom(const PakeRegistrationRequestAndUserID& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PakeRegistrationRequestAndUserID)
+ 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.pakeregistrationrequest().size() > 0) {
+ _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
+ }
+}
+
+void PakeRegistrationRequestAndUserID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PakeRegistrationRequestAndUserID)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PakeRegistrationRequestAndUserID::CopyFrom(const PakeRegistrationRequestAndUserID& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PakeRegistrationRequestAndUserID)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PakeRegistrationRequestAndUserID::IsInitialized() const {
+ return true;
+}
+
+void PakeRegistrationRequestAndUserID::InternalSwap(PakeRegistrationRequestAndUserID* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ pakeregistrationrequest_.Swap(&other->pakeregistrationrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PakeRegistrationRequestAndUserID::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class PakeAuthenticationRequestData::_Internal {
+ public:
+ static const ::backup::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid(const PakeAuthenticationRequestData* msg);
+};
+
+const ::backup::PakeRegistrationRequestAndUserID&
+PakeAuthenticationRequestData::_Internal::pakeregistrationrequestanduserid(const PakeAuthenticationRequestData* msg) {
+ return *msg->data_.pakeregistrationrequestanduserid_;
+}
+void PakeAuthenticationRequestData::set_allocated_pakeregistrationrequestanduserid(::backup::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (pakeregistrationrequestanduserid) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeregistrationrequestanduserid);
+ if (message_arena != submessage_arena) {
+ pakeregistrationrequestanduserid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, pakeregistrationrequestanduserid, submessage_arena);
+ }
+ set_has_pakeregistrationrequestanduserid();
+ data_.pakeregistrationrequestanduserid_ = pakeregistrationrequestanduserid;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.PakeAuthenticationRequestData.pakeRegistrationRequestAndUserID)
+}
+PakeAuthenticationRequestData::PakeAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.PakeAuthenticationRequestData)
+}
+PakeAuthenticationRequestData::PakeAuthenticationRequestData(const PakeAuthenticationRequestData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kPakeRegistrationRequestAndUserID: {
+ _internal_mutable_pakeregistrationrequestanduserid()->::backup::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
+ break;
+ }
+ case kPakeRegistrationUpload: {
+ _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
+ break;
+ }
+ case kPakeCredentialRequest: {
+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
+ break;
+ }
+ case kPakeCredentialFinalization: {
+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
+ break;
+ }
+ case kPakeClientMAC: {
+ _internal_set_pakeclientmac(from._internal_pakeclientmac());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.PakeAuthenticationRequestData)
+}
+
+void PakeAuthenticationRequestData::SharedCtor() {
+clear_has_data();
+}
+
+PakeAuthenticationRequestData::~PakeAuthenticationRequestData() {
+ // @@protoc_insertion_point(destructor:backup.PakeAuthenticationRequestData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void PakeAuthenticationRequestData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void PakeAuthenticationRequestData::ArenaDtor(void* object) {
+ PakeAuthenticationRequestData* _this = reinterpret_cast< PakeAuthenticationRequestData* >(object);
+ (void)_this;
+}
+void PakeAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void PakeAuthenticationRequestData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void PakeAuthenticationRequestData::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.PakeAuthenticationRequestData)
+ switch (data_case()) {
+ case kPakeRegistrationRequestAndUserID: {
+ if (GetArena() == nullptr) {
+ delete data_.pakeregistrationrequestanduserid_;
+ }
+ break;
+ }
+ case kPakeRegistrationUpload: {
+ data_.pakeregistrationupload_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kPakeCredentialRequest: {
+ data_.pakecredentialrequest_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kPakeCredentialFinalization: {
+ data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kPakeClientMAC: {
+ data_.pakeclientmac_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void PakeAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PakeAuthenticationRequestData)
+ ::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* PakeAuthenticationRequestData::_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.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_pakeregistrationrequestanduserid(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeRegistrationUpload = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_pakeregistrationupload();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeCredentialRequest = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_pakecredentialrequest();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeCredentialFinalization = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ auto str = _internal_mutable_pakecredentialfinalization();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeClientMAC = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
+ auto str = _internal_mutable_pakeclientmac();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* PakeAuthenticationRequestData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.PakeAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .backup.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+ if (_internal_has_pakeregistrationrequestanduserid()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::pakeregistrationrequestanduserid(this), target, stream);
+ }
+
+ // bytes pakeRegistrationUpload = 2;
+ if (_internal_has_pakeregistrationupload()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_pakeregistrationupload(), target);
+ }
+
+ // bytes pakeCredentialRequest = 3;
+ if (_internal_has_pakecredentialrequest()) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_pakecredentialrequest(), target);
+ }
+
+ // bytes pakeCredentialFinalization = 4;
+ if (_internal_has_pakecredentialfinalization()) {
+ target = stream->WriteBytesMaybeAliased(
+ 4, this->_internal_pakecredentialfinalization(), target);
+ }
+
+ // bytes pakeClientMAC = 5;
+ if (_internal_has_pakeclientmac()) {
+ target = stream->WriteBytesMaybeAliased(
+ 5, this->_internal_pakeclientmac(), 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.PakeAuthenticationRequestData)
+ return target;
+}
+
+size_t PakeAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PakeAuthenticationRequestData)
+ 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.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+ case kPakeRegistrationRequestAndUserID: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.pakeregistrationrequestanduserid_);
+ break;
+ }
+ // bytes pakeRegistrationUpload = 2;
+ case kPakeRegistrationUpload: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakeregistrationupload());
+ break;
+ }
+ // bytes pakeCredentialRequest = 3;
+ case kPakeCredentialRequest: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakecredentialrequest());
+ break;
+ }
+ // bytes pakeCredentialFinalization = 4;
+ case kPakeCredentialFinalization: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakecredentialfinalization());
+ break;
+ }
+ // bytes pakeClientMAC = 5;
+ case kPakeClientMAC: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakeclientmac());
+ 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 PakeAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PakeAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const PakeAuthenticationRequestData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeAuthenticationRequestData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PakeAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PakeAuthenticationRequestData)
+ MergeFrom(*source);
+ }
+}
+
+void PakeAuthenticationRequestData::MergeFrom(const PakeAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PakeAuthenticationRequestData)
+ 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 kPakeRegistrationRequestAndUserID: {
+ _internal_mutable_pakeregistrationrequestanduserid()->::backup::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
+ break;
+ }
+ case kPakeRegistrationUpload: {
+ _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
+ break;
+ }
+ case kPakeCredentialRequest: {
+ _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
+ break;
+ }
+ case kPakeCredentialFinalization: {
+ _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
+ break;
+ }
+ case kPakeClientMAC: {
+ _internal_set_pakeclientmac(from._internal_pakeclientmac());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void PakeAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PakeAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PakeAuthenticationRequestData::CopyFrom(const PakeAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PakeAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PakeAuthenticationRequestData::IsInitialized() const {
+ return true;
+}
+
+void PakeAuthenticationRequestData::InternalSwap(PakeAuthenticationRequestData* 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 PakeAuthenticationRequestData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class WalletAuthenticationRequestData::_Internal {
+ public:
+};
+
+WalletAuthenticationRequestData::WalletAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.WalletAuthenticationRequestData)
+}
+WalletAuthenticationRequestData::WalletAuthenticationRequestData(const WalletAuthenticationRequestData& 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());
+ }
+ walletaddress_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_walletaddress().empty()) {
+ walletaddress_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_walletaddress(),
+ GetArena());
+ }
+ signedmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_signedmessage().empty()) {
+ signedmessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_signedmessage(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.WalletAuthenticationRequestData)
+}
+
+void WalletAuthenticationRequestData::SharedCtor() {
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+walletaddress_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+signedmessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+WalletAuthenticationRequestData::~WalletAuthenticationRequestData() {
+ // @@protoc_insertion_point(destructor:backup.WalletAuthenticationRequestData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void WalletAuthenticationRequestData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ walletaddress_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ signedmessage_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void WalletAuthenticationRequestData::ArenaDtor(void* object) {
+ WalletAuthenticationRequestData* _this = reinterpret_cast< WalletAuthenticationRequestData* >(object);
+ (void)_this;
+}
+void WalletAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void WalletAuthenticationRequestData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void WalletAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.WalletAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ userid_.ClearToEmpty();
+ walletaddress_.ClearToEmpty();
+ signedmessage_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WalletAuthenticationRequestData::_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.WalletAuthenticationRequestData.userID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string walletAddress = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_walletaddress();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.WalletAuthenticationRequestData.walletAddress"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes signedMessage = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_signedmessage();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* WalletAuthenticationRequestData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.WalletAuthenticationRequestData)
+ ::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.WalletAuthenticationRequestData.userID");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_userid(), target);
+ }
+
+ // string walletAddress = 2;
+ if (this->walletaddress().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_walletaddress().data(), static_cast<int>(this->_internal_walletaddress().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.WalletAuthenticationRequestData.walletAddress");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_walletaddress(), target);
+ }
+
+ // bytes signedMessage = 3;
+ if (this->signedmessage().size() > 0) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_signedmessage(), 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.WalletAuthenticationRequestData)
+ return target;
+}
+
+size_t WalletAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.WalletAuthenticationRequestData)
+ 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 walletAddress = 2;
+ if (this->walletaddress().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_walletaddress());
+ }
+
+ // bytes signedMessage = 3;
+ if (this->signedmessage().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_signedmessage());
+ }
+
+ 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 WalletAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.WalletAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const WalletAuthenticationRequestData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletAuthenticationRequestData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.WalletAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.WalletAuthenticationRequestData)
+ MergeFrom(*source);
+ }
+}
+
+void WalletAuthenticationRequestData::MergeFrom(const WalletAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.WalletAuthenticationRequestData)
+ 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.walletaddress().size() > 0) {
+ _internal_set_walletaddress(from._internal_walletaddress());
+ }
+ if (from.signedmessage().size() > 0) {
+ _internal_set_signedmessage(from._internal_signedmessage());
+ }
+}
+
+void WalletAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.WalletAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void WalletAuthenticationRequestData::CopyFrom(const WalletAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.WalletAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool WalletAuthenticationRequestData::IsInitialized() const {
+ return true;
+}
+
+void WalletAuthenticationRequestData::InternalSwap(WalletAuthenticationRequestData* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ walletaddress_.Swap(&other->walletaddress_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ signedmessage_.Swap(&other->signedmessage_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WalletAuthenticationRequestData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class FullAuthenticationRequestData::_Internal {
+ public:
+ static const ::backup::PakeAuthenticationRequestData& pakeauthenticationrequestdata(const FullAuthenticationRequestData* msg);
+ static const ::backup::WalletAuthenticationRequestData& walletauthenticationrequestdata(const FullAuthenticationRequestData* msg);
+};
+
+const ::backup::PakeAuthenticationRequestData&
+FullAuthenticationRequestData::_Internal::pakeauthenticationrequestdata(const FullAuthenticationRequestData* msg) {
+ return *msg->data_.pakeauthenticationrequestdata_;
+}
+const ::backup::WalletAuthenticationRequestData&
+FullAuthenticationRequestData::_Internal::walletauthenticationrequestdata(const FullAuthenticationRequestData* msg) {
+ return *msg->data_.walletauthenticationrequestdata_;
+}
+void FullAuthenticationRequestData::set_allocated_pakeauthenticationrequestdata(::backup::PakeAuthenticationRequestData* pakeauthenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (pakeauthenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeauthenticationrequestdata);
+ if (message_arena != submessage_arena) {
+ pakeauthenticationrequestdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, pakeauthenticationrequestdata, submessage_arena);
+ }
+ set_has_pakeauthenticationrequestdata();
+ data_.pakeauthenticationrequestdata_ = pakeauthenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.pakeAuthenticationRequestData)
+}
+void FullAuthenticationRequestData::set_allocated_walletauthenticationrequestdata(::backup::WalletAuthenticationRequestData* walletauthenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (walletauthenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletauthenticationrequestdata);
+ if (message_arena != submessage_arena) {
+ walletauthenticationrequestdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, walletauthenticationrequestdata, submessage_arena);
+ }
+ set_has_walletauthenticationrequestdata();
+ data_.walletauthenticationrequestdata_ = walletauthenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationRequestData.walletAuthenticationRequestData)
+}
+FullAuthenticationRequestData::FullAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationRequestData)
+}
+FullAuthenticationRequestData::FullAuthenticationRequestData(const FullAuthenticationRequestData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kPakeAuthenticationRequestData: {
+ _internal_mutable_pakeauthenticationrequestdata()->::backup::PakeAuthenticationRequestData::MergeFrom(from._internal_pakeauthenticationrequestdata());
+ break;
+ }
+ case kWalletAuthenticationRequestData: {
+ _internal_mutable_walletauthenticationrequestdata()->::backup::WalletAuthenticationRequestData::MergeFrom(from._internal_walletauthenticationrequestdata());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationRequestData)
+}
+
+void FullAuthenticationRequestData::SharedCtor() {
+clear_has_data();
+}
+
+FullAuthenticationRequestData::~FullAuthenticationRequestData() {
+ // @@protoc_insertion_point(destructor:backup.FullAuthenticationRequestData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void FullAuthenticationRequestData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void FullAuthenticationRequestData::ArenaDtor(void* object) {
+ FullAuthenticationRequestData* _this = reinterpret_cast< FullAuthenticationRequestData* >(object);
+ (void)_this;
+}
+void FullAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FullAuthenticationRequestData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void FullAuthenticationRequestData::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationRequestData)
+ switch (data_case()) {
+ case kPakeAuthenticationRequestData: {
+ if (GetArena() == nullptr) {
+ delete data_.pakeauthenticationrequestdata_;
+ }
+ break;
+ }
+ case kWalletAuthenticationRequestData: {
+ if (GetArena() == nullptr) {
+ delete data_.walletauthenticationrequestdata_;
+ }
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void FullAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_data();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FullAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // .backup.PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_pakeauthenticationrequestdata(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .backup.WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_walletauthenticationrequestdata(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* FullAuthenticationRequestData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .backup.PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+ if (_internal_has_pakeauthenticationrequestdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::pakeauthenticationrequestdata(this), target, stream);
+ }
+
+ // .backup.WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+ if (_internal_has_walletauthenticationrequestdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::walletauthenticationrequestdata(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:backup.FullAuthenticationRequestData)
+ return target;
+}
+
+size_t FullAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationRequestData)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (data_case()) {
+ // .backup.PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+ case kPakeAuthenticationRequestData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.pakeauthenticationrequestdata_);
+ break;
+ }
+ // .backup.WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+ case kWalletAuthenticationRequestData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.walletauthenticationrequestdata_);
+ 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 FullAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const FullAuthenticationRequestData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationRequestData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationRequestData)
+ MergeFrom(*source);
+ }
+}
+
+void FullAuthenticationRequestData::MergeFrom(const FullAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.data_case()) {
+ case kPakeAuthenticationRequestData: {
+ _internal_mutable_pakeauthenticationrequestdata()->::backup::PakeAuthenticationRequestData::MergeFrom(from._internal_pakeauthenticationrequestdata());
+ break;
+ }
+ case kWalletAuthenticationRequestData: {
+ _internal_mutable_walletauthenticationrequestdata()->::backup::WalletAuthenticationRequestData::MergeFrom(from._internal_walletauthenticationrequestdata());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void FullAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void FullAuthenticationRequestData::CopyFrom(const FullAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool FullAuthenticationRequestData::IsInitialized() const {
+ return true;
+}
+
+void FullAuthenticationRequestData::InternalSwap(FullAuthenticationRequestData* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ swap(data_, other->data_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FullAuthenticationRequestData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class WalletAuthenticationResponseData::_Internal {
+ public:
+};
+
+WalletAuthenticationResponseData::WalletAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.WalletAuthenticationResponseData)
+}
+WalletAuthenticationResponseData::WalletAuthenticationResponseData(const WalletAuthenticationResponseData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ success_ = from.success_;
+ // @@protoc_insertion_point(copy_constructor:backup.WalletAuthenticationResponseData)
+}
+
+void WalletAuthenticationResponseData::SharedCtor() {
+success_ = false;
+}
+
+WalletAuthenticationResponseData::~WalletAuthenticationResponseData() {
+ // @@protoc_insertion_point(destructor:backup.WalletAuthenticationResponseData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void WalletAuthenticationResponseData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void WalletAuthenticationResponseData::ArenaDtor(void* object) {
+ WalletAuthenticationResponseData* _this = reinterpret_cast< WalletAuthenticationResponseData* >(object);
+ (void)_this;
+}
+void WalletAuthenticationResponseData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void WalletAuthenticationResponseData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void WalletAuthenticationResponseData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.WalletAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ success_ = false;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* WalletAuthenticationResponseData::_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) {
+ // bool success = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+ success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ 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* WalletAuthenticationResponseData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.WalletAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bool success = 1;
+ if (this->success() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_success(), 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.WalletAuthenticationResponseData)
+ return target;
+}
+
+size_t WalletAuthenticationResponseData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.WalletAuthenticationResponseData)
+ 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;
+
+ // bool success = 1;
+ if (this->success() != 0) {
+ total_size += 1 + 1;
+ }
+
+ 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 WalletAuthenticationResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.WalletAuthenticationResponseData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const WalletAuthenticationResponseData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletAuthenticationResponseData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.WalletAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.WalletAuthenticationResponseData)
+ MergeFrom(*source);
+ }
+}
+
+void WalletAuthenticationResponseData::MergeFrom(const WalletAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.WalletAuthenticationResponseData)
+ 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.success() != 0) {
+ _internal_set_success(from._internal_success());
+ }
+}
+
+void WalletAuthenticationResponseData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.WalletAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void WalletAuthenticationResponseData::CopyFrom(const WalletAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.WalletAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool WalletAuthenticationResponseData::IsInitialized() const {
+ return true;
+}
+
+void WalletAuthenticationResponseData::InternalSwap(WalletAuthenticationResponseData* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ swap(success_, other->success_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata WalletAuthenticationResponseData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class PakeAuthenticationResponseData::_Internal {
+ public:
+};
+
+PakeAuthenticationResponseData::PakeAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.PakeAuthenticationResponseData)
+}
+PakeAuthenticationResponseData::PakeAuthenticationResponseData(const PakeAuthenticationResponseData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kPakeRegistrationResponse: {
+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
+ break;
+ }
+ case kPakeRegistrationSuccess: {
+ _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
+ break;
+ }
+ case kPakeCredentialResponse: {
+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
+ break;
+ }
+ case kPakeServerMAC: {
+ _internal_set_pakeservermac(from._internal_pakeservermac());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.PakeAuthenticationResponseData)
+}
+
+void PakeAuthenticationResponseData::SharedCtor() {
+clear_has_data();
+}
+
+PakeAuthenticationResponseData::~PakeAuthenticationResponseData() {
+ // @@protoc_insertion_point(destructor:backup.PakeAuthenticationResponseData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void PakeAuthenticationResponseData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void PakeAuthenticationResponseData::ArenaDtor(void* object) {
+ PakeAuthenticationResponseData* _this = reinterpret_cast< PakeAuthenticationResponseData* >(object);
+ (void)_this;
+}
+void PakeAuthenticationResponseData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void PakeAuthenticationResponseData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void PakeAuthenticationResponseData::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.PakeAuthenticationResponseData)
+ switch (data_case()) {
+ case kPakeRegistrationResponse: {
+ data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kPakeRegistrationSuccess: {
+ // No need to clear
+ break;
+ }
+ case kPakeCredentialResponse: {
+ data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kPakeServerMAC: {
+ data_.pakeservermac_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void PakeAuthenticationResponseData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PakeAuthenticationResponseData)
+ ::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* PakeAuthenticationResponseData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // bytes pakeRegistrationResponse = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_pakeregistrationresponse();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bool pakeRegistrationSuccess = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ _internal_set_pakeregistrationsuccess(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeCredentialResponse = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_pakecredentialresponse();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes pakeServerMAC = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ auto str = _internal_mutable_pakeservermac();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* PakeAuthenticationResponseData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.PakeAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes pakeRegistrationResponse = 1;
+ if (_internal_has_pakeregistrationresponse()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_pakeregistrationresponse(), target);
+ }
+
+ // bool pakeRegistrationSuccess = 2;
+ if (_internal_has_pakeregistrationsuccess()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_pakeregistrationsuccess(), target);
+ }
+
+ // bytes pakeCredentialResponse = 3;
+ if (_internal_has_pakecredentialresponse()) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_pakecredentialresponse(), target);
+ }
+
+ // bytes pakeServerMAC = 4;
+ if (_internal_has_pakeservermac()) {
+ target = stream->WriteBytesMaybeAliased(
+ 4, this->_internal_pakeservermac(), 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.PakeAuthenticationResponseData)
+ return target;
+}
+
+size_t PakeAuthenticationResponseData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PakeAuthenticationResponseData)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (data_case()) {
+ // bytes pakeRegistrationResponse = 1;
+ case kPakeRegistrationResponse: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakeregistrationresponse());
+ break;
+ }
+ // bool pakeRegistrationSuccess = 2;
+ case kPakeRegistrationSuccess: {
+ total_size += 1 + 1;
+ break;
+ }
+ // bytes pakeCredentialResponse = 3;
+ case kPakeCredentialResponse: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakecredentialresponse());
+ break;
+ }
+ // bytes pakeServerMAC = 4;
+ case kPakeServerMAC: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_pakeservermac());
+ 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 PakeAuthenticationResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PakeAuthenticationResponseData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const PakeAuthenticationResponseData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeAuthenticationResponseData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PakeAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PakeAuthenticationResponseData)
+ MergeFrom(*source);
+ }
+}
+
+void PakeAuthenticationResponseData::MergeFrom(const PakeAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PakeAuthenticationResponseData)
+ 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 kPakeRegistrationResponse: {
+ _internal_set_pakeregistrationresponse(from._internal_pakeregistrationresponse());
+ break;
+ }
+ case kPakeRegistrationSuccess: {
+ _internal_set_pakeregistrationsuccess(from._internal_pakeregistrationsuccess());
+ break;
+ }
+ case kPakeCredentialResponse: {
+ _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
+ break;
+ }
+ case kPakeServerMAC: {
+ _internal_set_pakeservermac(from._internal_pakeservermac());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void PakeAuthenticationResponseData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PakeAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void PakeAuthenticationResponseData::CopyFrom(const PakeAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PakeAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool PakeAuthenticationResponseData::IsInitialized() const {
+ return true;
+}
+
+void PakeAuthenticationResponseData::InternalSwap(PakeAuthenticationResponseData* 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 PakeAuthenticationResponseData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class FullAuthenticationResponseData::_Internal {
+ public:
+ static const ::backup::PakeAuthenticationResponseData& pakeauthenticationresponsedata(const FullAuthenticationResponseData* msg);
+ static const ::backup::WalletAuthenticationResponseData& walletauthenticationresponsedata(const FullAuthenticationResponseData* msg);
+};
+
+const ::backup::PakeAuthenticationResponseData&
+FullAuthenticationResponseData::_Internal::pakeauthenticationresponsedata(const FullAuthenticationResponseData* msg) {
+ return *msg->data_.pakeauthenticationresponsedata_;
+}
+const ::backup::WalletAuthenticationResponseData&
+FullAuthenticationResponseData::_Internal::walletauthenticationresponsedata(const FullAuthenticationResponseData* msg) {
+ return *msg->data_.walletauthenticationresponsedata_;
+}
+void FullAuthenticationResponseData::set_allocated_pakeauthenticationresponsedata(::backup::PakeAuthenticationResponseData* pakeauthenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (pakeauthenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeauthenticationresponsedata);
+ if (message_arena != submessage_arena) {
+ pakeauthenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, pakeauthenticationresponsedata, submessage_arena);
+ }
+ set_has_pakeauthenticationresponsedata();
+ data_.pakeauthenticationresponsedata_ = pakeauthenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.pakeAuthenticationResponseData)
+}
+void FullAuthenticationResponseData::set_allocated_walletauthenticationresponsedata(::backup::WalletAuthenticationResponseData* walletauthenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (walletauthenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletauthenticationresponsedata);
+ if (message_arena != submessage_arena) {
+ walletauthenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, walletauthenticationresponsedata, submessage_arena);
+ }
+ set_has_walletauthenticationresponsedata();
+ data_.walletauthenticationresponsedata_ = walletauthenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.FullAuthenticationResponseData.walletAuthenticationResponseData)
+}
+FullAuthenticationResponseData::FullAuthenticationResponseData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.FullAuthenticationResponseData)
+}
+FullAuthenticationResponseData::FullAuthenticationResponseData(const FullAuthenticationResponseData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kPakeAuthenticationResponseData: {
+ _internal_mutable_pakeauthenticationresponsedata()->::backup::PakeAuthenticationResponseData::MergeFrom(from._internal_pakeauthenticationresponsedata());
+ break;
+ }
+ case kWalletAuthenticationResponseData: {
+ _internal_mutable_walletauthenticationresponsedata()->::backup::WalletAuthenticationResponseData::MergeFrom(from._internal_walletauthenticationresponsedata());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.FullAuthenticationResponseData)
+}
+
+void FullAuthenticationResponseData::SharedCtor() {
+clear_has_data();
+}
+
+FullAuthenticationResponseData::~FullAuthenticationResponseData() {
+ // @@protoc_insertion_point(destructor:backup.FullAuthenticationResponseData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void FullAuthenticationResponseData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void FullAuthenticationResponseData::ArenaDtor(void* object) {
+ FullAuthenticationResponseData* _this = reinterpret_cast< FullAuthenticationResponseData* >(object);
+ (void)_this;
+}
+void FullAuthenticationResponseData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FullAuthenticationResponseData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void FullAuthenticationResponseData::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.FullAuthenticationResponseData)
+ switch (data_case()) {
+ case kPakeAuthenticationResponseData: {
+ if (GetArena() == nullptr) {
+ delete data_.pakeauthenticationresponsedata_;
+ }
+ break;
+ }
+ case kWalletAuthenticationResponseData: {
+ if (GetArena() == nullptr) {
+ delete data_.walletauthenticationresponsedata_;
+ }
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void FullAuthenticationResponseData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.FullAuthenticationResponseData)
+ ::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* FullAuthenticationResponseData::_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.PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_pakeauthenticationresponsedata(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .backup.WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_walletauthenticationresponsedata(), ptr);
+ 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* FullAuthenticationResponseData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.FullAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .backup.PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+ if (_internal_has_pakeauthenticationresponsedata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::pakeauthenticationresponsedata(this), target, stream);
+ }
+
+ // .backup.WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+ if (_internal_has_walletauthenticationresponsedata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::walletauthenticationresponsedata(this), target, stream);
+ }
+
+ 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.FullAuthenticationResponseData)
+ return target;
+}
+
+size_t FullAuthenticationResponseData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.FullAuthenticationResponseData)
+ 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.PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+ case kPakeAuthenticationResponseData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.pakeauthenticationresponsedata_);
+ break;
+ }
+ // .backup.WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+ case kWalletAuthenticationResponseData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.walletauthenticationresponsedata_);
+ 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 FullAuthenticationResponseData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.FullAuthenticationResponseData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const FullAuthenticationResponseData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<FullAuthenticationResponseData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.FullAuthenticationResponseData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.FullAuthenticationResponseData)
+ MergeFrom(*source);
+ }
+}
+
+void FullAuthenticationResponseData::MergeFrom(const FullAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.FullAuthenticationResponseData)
+ 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 kPakeAuthenticationResponseData: {
+ _internal_mutable_pakeauthenticationresponsedata()->::backup::PakeAuthenticationResponseData::MergeFrom(from._internal_pakeauthenticationresponsedata());
+ break;
+ }
+ case kWalletAuthenticationResponseData: {
+ _internal_mutable_walletauthenticationresponsedata()->::backup::WalletAuthenticationResponseData::MergeFrom(from._internal_walletauthenticationresponsedata());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void FullAuthenticationResponseData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.FullAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void FullAuthenticationResponseData::CopyFrom(const FullAuthenticationResponseData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.FullAuthenticationResponseData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool FullAuthenticationResponseData::IsInitialized() const {
+ return true;
+}
+
+void FullAuthenticationResponseData::InternalSwap(FullAuthenticationResponseData* 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 FullAuthenticationResponseData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class SimpleAuthenticationRequestData::_Internal {
+ public:
+};
+
+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.SimpleAuthenticationRequestData)
+}
+SimpleAuthenticationRequestData::SimpleAuthenticationRequestData(const SimpleAuthenticationRequestData& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_backupid().empty()) {
+ backupid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_backupid(),
+ GetArena());
+ }
+ userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_userid().empty()) {
+ userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.SimpleAuthenticationRequestData)
+}
+
+void SimpleAuthenticationRequestData::SharedCtor() {
+backupid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+SimpleAuthenticationRequestData::~SimpleAuthenticationRequestData() {
+ // @@protoc_insertion_point(destructor:backup.SimpleAuthenticationRequestData)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void SimpleAuthenticationRequestData::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ backupid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleAuthenticationRequestData::ArenaDtor(void* object) {
+ SimpleAuthenticationRequestData* _this = reinterpret_cast< SimpleAuthenticationRequestData* >(object);
+ (void)_this;
+}
+void SimpleAuthenticationRequestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleAuthenticationRequestData::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void SimpleAuthenticationRequestData::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.SimpleAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ backupid_.ClearToEmpty();
+ userid_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleAuthenticationRequestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // string backupID = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_backupid();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.backupID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string userID = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_userid();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SimpleAuthenticationRequestData.userID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* SimpleAuthenticationRequestData::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.SimpleAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string backupID = 1;
+ if (this->backupid().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.SimpleAuthenticationRequestData.backupID");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_backupid(), target);
+ }
+
+ // string userID = 2;
+ if (this->userid().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.SimpleAuthenticationRequestData.userID");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_userid(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:backup.SimpleAuthenticationRequestData)
+ return target;
+}
+
+size_t SimpleAuthenticationRequestData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.SimpleAuthenticationRequestData)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string backupID = 1;
+ if (this->backupid().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_backupid());
+ }
+
+ // string userID = 2;
+ if (this->userid().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_userid());
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void SimpleAuthenticationRequestData::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.SimpleAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ const SimpleAuthenticationRequestData* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SimpleAuthenticationRequestData>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.SimpleAuthenticationRequestData)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.SimpleAuthenticationRequestData)
+ MergeFrom(*source);
+ }
+}
+
+void SimpleAuthenticationRequestData::MergeFrom(const SimpleAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.SimpleAuthenticationRequestData)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from.backupid().size() > 0) {
+ _internal_set_backupid(from._internal_backupid());
+ }
+ if (from.userid().size() > 0) {
+ _internal_set_userid(from._internal_userid());
+ }
+}
+
+void SimpleAuthenticationRequestData::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.SimpleAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void SimpleAuthenticationRequestData::CopyFrom(const SimpleAuthenticationRequestData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.SimpleAuthenticationRequestData)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool SimpleAuthenticationRequestData::IsInitialized() const {
+ return true;
+}
+
+void SimpleAuthenticationRequestData::InternalSwap(SimpleAuthenticationRequestData* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ backupid_.Swap(&other->backupid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleAuthenticationRequestData::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class BackupKeyEntropy::_Internal {
+ public:
+};
+
+BackupKeyEntropy::BackupKeyEntropy(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.BackupKeyEntropy)
+}
+BackupKeyEntropy::BackupKeyEntropy(const BackupKeyEntropy& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kNonce: {
+ _internal_set_nonce(from._internal_nonce());
+ break;
+ }
+ case kRawMessage: {
+ _internal_set_rawmessage(from._internal_rawmessage());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.BackupKeyEntropy)
+}
+
+void BackupKeyEntropy::SharedCtor() {
+clear_has_data();
+}
+
+BackupKeyEntropy::~BackupKeyEntropy() {
+ // @@protoc_insertion_point(destructor:backup.BackupKeyEntropy)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void BackupKeyEntropy::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void BackupKeyEntropy::ArenaDtor(void* object) {
+ BackupKeyEntropy* _this = reinterpret_cast< BackupKeyEntropy* >(object);
+ (void)_this;
+}
+void BackupKeyEntropy::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void BackupKeyEntropy::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void BackupKeyEntropy::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.BackupKeyEntropy)
+ switch (data_case()) {
+ case kNonce: {
+ data_.nonce_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case kRawMessage: {
+ data_.rawmessage_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void BackupKeyEntropy::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.BackupKeyEntropy)
+ ::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* BackupKeyEntropy::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // bytes nonce = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_nonce();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes rawMessage = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_rawmessage();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BackupKeyEntropy::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.BackupKeyEntropy)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // bytes nonce = 1;
+ if (_internal_has_nonce()) {
+ target = stream->WriteBytesMaybeAliased(
+ 1, this->_internal_nonce(), target);
+ }
+
+ // bytes rawMessage = 2;
+ if (_internal_has_rawmessage()) {
+ target = stream->WriteBytesMaybeAliased(
+ 2, this->_internal_rawmessage(), 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.BackupKeyEntropy)
+ return target;
+}
+
+size_t BackupKeyEntropy::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.BackupKeyEntropy)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (data_case()) {
+ // bytes nonce = 1;
+ case kNonce: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_nonce());
+ break;
+ }
+ // bytes rawMessage = 2;
+ case kRawMessage: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_rawmessage());
+ 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 BackupKeyEntropy::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.BackupKeyEntropy)
+ GOOGLE_DCHECK_NE(&from, this);
+ const BackupKeyEntropy* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BackupKeyEntropy>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.BackupKeyEntropy)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.BackupKeyEntropy)
+ MergeFrom(*source);
+ }
+}
+
+void BackupKeyEntropy::MergeFrom(const BackupKeyEntropy& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.BackupKeyEntropy)
+ 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 kNonce: {
+ _internal_set_nonce(from._internal_nonce());
+ break;
+ }
+ case kRawMessage: {
+ _internal_set_rawmessage(from._internal_rawmessage());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void BackupKeyEntropy::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.BackupKeyEntropy)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void BackupKeyEntropy::CopyFrom(const BackupKeyEntropy& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.BackupKeyEntropy)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool BackupKeyEntropy::IsInitialized() const {
+ return true;
+}
+
+void BackupKeyEntropy::InternalSwap(BackupKeyEntropy* 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 BackupKeyEntropy::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class CreateNewBackupRequest::_Internal {
+ public:
+ static const ::backup::FullAuthenticationRequestData& authenticationrequestdata(const CreateNewBackupRequest* msg);
+ static const ::backup::BackupKeyEntropy& backupkeyentropy(const CreateNewBackupRequest* msg);
+};
+
+const ::backup::FullAuthenticationRequestData&
+CreateNewBackupRequest::_Internal::authenticationrequestdata(const CreateNewBackupRequest* msg) {
+ return *msg->data_.authenticationrequestdata_;
+}
+const ::backup::BackupKeyEntropy&
+CreateNewBackupRequest::_Internal::backupkeyentropy(const CreateNewBackupRequest* msg) {
+ return *msg->data_.backupkeyentropy_;
+}
+void CreateNewBackupRequest::set_allocated_authenticationrequestdata(::backup::FullAuthenticationRequestData* authenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (authenticationrequestdata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationrequestdata);
+ if (message_arena != submessage_arena) {
+ authenticationrequestdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationrequestdata, submessage_arena);
+ }
+ set_has_authenticationrequestdata();
+ data_.authenticationrequestdata_ = authenticationrequestdata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.authenticationRequestData)
+}
+void CreateNewBackupRequest::set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (backupkeyentropy) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(backupkeyentropy);
+ if (message_arena != submessage_arena) {
+ backupkeyentropy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, backupkeyentropy, submessage_arena);
+ }
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = backupkeyentropy;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupRequest.backupKeyEntropy)
+}
+CreateNewBackupRequest::CreateNewBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupRequest)
+}
+CreateNewBackupRequest::CreateNewBackupRequest(const CreateNewBackupRequest& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_data();
+ switch (from.data_case()) {
+ case kAuthenticationRequestData: {
+ _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
+ break;
+ }
+ case kBackupKeyEntropy: {
+ _internal_mutable_backupkeyentropy()->::backup::BackupKeyEntropy::MergeFrom(from._internal_backupkeyentropy());
+ break;
+ }
+ case kNewCompactionChunk: {
+ _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupRequest)
+}
+
+void CreateNewBackupRequest::SharedCtor() {
+clear_has_data();
+}
+
+CreateNewBackupRequest::~CreateNewBackupRequest() {
+ // @@protoc_insertion_point(destructor:backup.CreateNewBackupRequest)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void CreateNewBackupRequest::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ if (has_data()) {
+ clear_data();
+ }
+}
+
+void CreateNewBackupRequest::ArenaDtor(void* object) {
+ CreateNewBackupRequest* _this = reinterpret_cast< CreateNewBackupRequest* >(object);
+ (void)_this;
+}
+void CreateNewBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void CreateNewBackupRequest::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void CreateNewBackupRequest::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupRequest)
+ switch (data_case()) {
+ case kAuthenticationRequestData: {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationrequestdata_;
+ }
+ break;
+ }
+ case kBackupKeyEntropy: {
+ if (GetArena() == nullptr) {
+ delete data_.backupkeyentropy_;
+ }
+ break;
+ }
+ case kNewCompactionChunk: {
+ data_.newcompactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void CreateNewBackupRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupRequest)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_data();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* CreateNewBackupRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ CHK_(ptr);
+ switch (tag >> 3) {
+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationrequestdata(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_backupkeyentropy(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // bytes newCompactionChunk = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_newcompactionchunk();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ default: {
+ handle_unusual:
+ if ((tag & 7) == 4 || tag == 0) {
+ ctx->SetLastTag(tag);
+ goto success;
+ }
+ ptr = UnknownFieldParse(tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ continue;
+ }
+ } // switch
+ } // while
+success:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupRequest::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupRequest)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+ if (_internal_has_authenticationrequestdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationrequestdata(this), target, stream);
+ }
+
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ if (_internal_has_backupkeyentropy()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::backupkeyentropy(this), target, stream);
+ }
+
+ // bytes newCompactionChunk = 3;
+ if (_internal_has_newcompactionchunk()) {
+ target = stream->WriteBytesMaybeAliased(
+ 3, this->_internal_newcompactionchunk(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupRequest)
+ return target;
+}
+
+size_t CreateNewBackupRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupRequest)
+ size_t total_size = 0;
+
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (data_case()) {
+ // .backup.FullAuthenticationRequestData authenticationRequestData = 1;
+ case kAuthenticationRequestData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.authenticationrequestdata_);
+ break;
+ }
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ case kBackupKeyEntropy: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.backupkeyentropy_);
+ break;
+ }
+ // bytes newCompactionChunk = 3;
+ case kNewCompactionChunk: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_newcompactionchunk());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
+ _internal_metadata_, total_size, &_cached_size_);
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+ SetCachedSize(cached_size);
+ return total_size;
+}
+
+void CreateNewBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupRequest)
+ GOOGLE_DCHECK_NE(&from, this);
+ const CreateNewBackupRequest* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupRequest>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupRequest)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupRequest)
+ MergeFrom(*source);
+ }
+}
+
+void CreateNewBackupRequest::MergeFrom(const CreateNewBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupRequest)
+ GOOGLE_DCHECK_NE(&from, this);
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.data_case()) {
+ case kAuthenticationRequestData: {
+ _internal_mutable_authenticationrequestdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationrequestdata());
+ break;
+ }
+ case kBackupKeyEntropy: {
+ _internal_mutable_backupkeyentropy()->::backup::BackupKeyEntropy::MergeFrom(from._internal_backupkeyentropy());
+ break;
+ }
+ case kNewCompactionChunk: {
+ _internal_set_newcompactionchunk(from._internal_newcompactionchunk());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+}
+
+void CreateNewBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupRequest)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void CreateNewBackupRequest::CopyFrom(const CreateNewBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupRequest)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool CreateNewBackupRequest::IsInitialized() const {
+ return true;
+}
+
+void CreateNewBackupRequest::InternalSwap(CreateNewBackupRequest* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ swap(data_, other->data_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupRequest::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class CreateNewBackupResponse::_Internal {
+ public:
+ static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const CreateNewBackupResponse* msg);
+};
+
+const ::backup::FullAuthenticationResponseData&
+CreateNewBackupResponse::_Internal::authenticationresponsedata(const CreateNewBackupResponse* msg) {
+ return *msg->data_.authenticationresponsedata_;
+}
+void CreateNewBackupResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (authenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
+ if (message_arena != submessage_arena) {
+ authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationresponsedata, submessage_arena);
+ }
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = authenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.CreateNewBackupResponse.authenticationResponseData)
+}
+CreateNewBackupResponse::CreateNewBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:backup.CreateNewBackupResponse)
+}
+CreateNewBackupResponse::CreateNewBackupResponse(const CreateNewBackupResponse& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
clear_has_data();
switch (from.data_case()) {
- case kNewKey: {
- _internal_set_newkey(from._internal_newkey());
+ case kAuthenticationResponseData: {
+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
break;
}
- case kCompactionChunk: {
- _internal_set_compactionchunk(from._internal_compactionchunk());
+ case kEntropyValid: {
+ _internal_set_entropyvalid(from._internal_entropyvalid());
+ break;
+ }
+ case kBackupID: {
+ _internal_set_backupid(from._internal_backupid());
break;
}
case DATA_NOT_SET: {
break;
}
}
- // @@protoc_insertion_point(copy_constructor:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(copy_constructor:backup.CreateNewBackupResponse)
}
-void ResetKeyRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void CreateNewBackupResponse::SharedCtor() {
clear_has_data();
}
-ResetKeyRequest::~ResetKeyRequest() {
- // @@protoc_insertion_point(destructor:backup.ResetKeyRequest)
+CreateNewBackupResponse::~CreateNewBackupResponse() {
+ // @@protoc_insertion_point(destructor:backup.CreateNewBackupResponse)
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-void ResetKeyRequest::SharedDtor() {
+void CreateNewBackupResponse::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (has_data()) {
clear_data();
}
}
-void ResetKeyRequest::ArenaDtor(void* object) {
- ResetKeyRequest* _this = reinterpret_cast< ResetKeyRequest* >(object);
+void CreateNewBackupResponse::ArenaDtor(void* object) {
+ CreateNewBackupResponse* _this = reinterpret_cast< CreateNewBackupResponse* >(object);
(void)_this;
}
-void ResetKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void CreateNewBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
-void ResetKeyRequest::SetCachedSize(int size) const {
+void CreateNewBackupResponse::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-void ResetKeyRequest::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.CreateNewBackupResponse)
switch (data_case()) {
- case kNewKey: {
- data_.newkey_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ case kAuthenticationResponseData: {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationresponsedata_;
+ }
break;
}
- case kCompactionChunk: {
- data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ case kEntropyValid: {
+ // No need to clear
+ break;
+ }
+ case kBackupID: {
+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
break;
}
case DATA_NOT_SET: {
@@ -288,46 +3437,43 @@
}
-void ResetKeyRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.CreateNewBackupResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- userid_.ClearToEmpty();
clear_data();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-const char* ResetKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* CreateNewBackupResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
- // string userId = 1;
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 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.ResetKeyRequest.userId"));
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
- // bytes newKey = 2;
+ // bool entropyValid = 2;
case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_newkey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+ _internal_set_entropyvalid(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
CHK_(ptr);
} else goto handle_unusual;
continue;
- // bytes compactionChunk = 3;
+ // string backupID = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
- auto str = _internal_mutable_compactionchunk();
+ auto str = _internal_mutable_backupid();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.CreateNewBackupResponse.backupID"));
CHK_(ptr);
} else goto handle_unusual;
continue;
@@ -353,70 +3499,70 @@
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* ResetKeyRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* CreateNewBackupResponse::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(serialize_to_array_start:backup.CreateNewBackupResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- // string userId = 1;
- if (this->userid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "backup.ResetKeyRequest.userId");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ if (_internal_has_authenticationresponsedata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationresponsedata(this), target, stream);
}
- // bytes newKey = 2;
- if (_internal_has_newkey()) {
- target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_newkey(), target);
+ // bool entropyValid = 2;
+ if (_internal_has_entropyvalid()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_entropyvalid(), target);
}
- // bytes compactionChunk = 3;
- if (_internal_has_compactionchunk()) {
- target = stream->WriteBytesMaybeAliased(
- 3, this->_internal_compactionchunk(), target);
+ // string backupID = 3;
+ if (_internal_has_backupid()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.CreateNewBackupResponse.backupID");
+ target = stream->WriteStringMaybeAliased(
+ 3, this->_internal_backupid(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
- // @@protoc_insertion_point(serialize_to_array_end:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(serialize_to_array_end:backup.CreateNewBackupResponse)
return target;
}
-size_t ResetKeyRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.ResetKeyRequest)
+size_t CreateNewBackupResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.CreateNewBackupResponse)
size_t total_size = 0;
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- // string userId = 1;
- if (this->userid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userid());
- }
-
switch (data_case()) {
- // bytes newKey = 2;
- case kNewKey: {
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ case kAuthenticationResponseData: {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_newkey());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.authenticationresponsedata_);
break;
}
- // bytes compactionChunk = 3;
- case kCompactionChunk: {
+ // bool entropyValid = 2;
+ case kEntropyValid: {
+ total_size += 1 + 1;
+ break;
+ }
+ // string backupID = 3;
+ case kBackupID: {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_compactionchunk());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_backupid());
break;
}
case DATA_NOT_SET: {
@@ -432,38 +3578,39 @@
return total_size;
}
-void ResetKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.CreateNewBackupResponse)
GOOGLE_DCHECK_NE(&from, this);
- const ResetKeyRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<ResetKeyRequest>(
+ const CreateNewBackupResponse* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CreateNewBackupResponse>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.CreateNewBackupResponse)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.ResetKeyRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.CreateNewBackupResponse)
MergeFrom(*source);
}
}
-void ResetKeyRequest::MergeFrom(const ResetKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::MergeFrom(const CreateNewBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.CreateNewBackupResponse)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- if (from.userid().size() > 0) {
- _internal_set_userid(from._internal_userid());
- }
switch (from.data_case()) {
- case kNewKey: {
- _internal_set_newkey(from._internal_newkey());
+ case kAuthenticationResponseData: {
+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
break;
}
- case kCompactionChunk: {
- _internal_set_compactionchunk(from._internal_compactionchunk());
+ case kEntropyValid: {
+ _internal_set_entropyvalid(from._internal_entropyvalid());
+ break;
+ }
+ case kBackupID: {
+ _internal_set_backupid(from._internal_backupid());
break;
}
case DATA_NOT_SET: {
@@ -472,33 +3619,32 @@
}
}
-void ResetKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.CreateNewBackupResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void ResetKeyRequest::CopyFrom(const ResetKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.ResetKeyRequest)
+void CreateNewBackupResponse::CopyFrom(const CreateNewBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.CreateNewBackupResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool ResetKeyRequest::IsInitialized() const {
+bool CreateNewBackupResponse::IsInitialized() const {
return true;
}
-void ResetKeyRequest::InternalSwap(ResetKeyRequest* other) {
+void CreateNewBackupResponse::InternalSwap(CreateNewBackupResponse* other) {
using std::swap;
_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
swap(data_, other->data_);
swap(_oneof_case_[0], other->_oneof_case_[0]);
}
-::PROTOBUF_NAMESPACE_ID::Metadata ResetKeyRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata CreateNewBackupResponse::GetMetadata() const {
return GetMetadataStatic();
}
@@ -507,8 +3653,13 @@
class SendLogRequest::_Internal {
public:
+ static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const SendLogRequest* msg);
};
+const ::backup::SimpleAuthenticationRequestData&
+SendLogRequest::_Internal::authenticationdata(const SendLogRequest* msg) {
+ return *msg->authenticationdata_;
+}
SendLogRequest::SendLogRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
@@ -518,22 +3669,22 @@
SendLogRequest::SendLogRequest(const SendLogRequest& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userid().empty()) {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
+ logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_logdata().empty()) {
+ logdata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_logdata(),
GetArena());
}
- data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_data().empty()) {
- data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
- GetArena());
+ if (from._internal_has_authenticationdata()) {
+ authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
+ } else {
+ authenticationdata_ = nullptr;
}
// @@protoc_insertion_point(copy_constructor:backup.SendLogRequest)
}
void SendLogRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+logdata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+authenticationdata_ = nullptr;
}
SendLogRequest::~SendLogRequest() {
@@ -544,8 +3695,8 @@
void SendLogRequest::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ logdata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete authenticationdata_;
}
void SendLogRequest::ArenaDtor(void* object) {
@@ -564,8 +3715,11 @@
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- userid_.ClearToEmpty();
- data_.ClearToEmpty();
+ logdata_.ClearToEmpty();
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
@@ -576,19 +3730,17 @@
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
- // string userId = 1;
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_userid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.SendLogRequest.userId"));
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
- // bytes data = 2;
+ // bytes logData = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_data();
+ auto str = _internal_mutable_logdata();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else goto handle_unusual;
@@ -621,20 +3773,18 @@
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- // string userId = 1;
- if (this->userid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "backup.SendLogRequest.userId");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationdata(this), target, stream);
}
- // bytes data = 2;
- if (this->data().size() > 0) {
+ // bytes logData = 2;
+ if (this->logdata().size() > 0) {
target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_data(), target);
+ 2, this->_internal_logdata(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -653,18 +3803,18 @@
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- // string userId = 1;
- if (this->userid().size() > 0) {
+ // bytes logData = 2;
+ if (this->logdata().size() > 0) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userid());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ this->_internal_logdata());
}
- // bytes data = 2;
- if (this->data().size() > 0) {
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_data());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *authenticationdata_);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -698,11 +3848,11 @@
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- if (from.userid().size() > 0) {
- _internal_set_userid(from._internal_userid());
+ if (from.logdata().size() > 0) {
+ _internal_set_logdata(from._internal_logdata());
}
- if (from.data().size() > 0) {
- _internal_set_data(from._internal_data());
+ if (from.has_authenticationdata()) {
+ _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
}
}
@@ -727,8 +3877,8 @@
void SendLogRequest::InternalSwap(SendLogRequest* other) {
using std::swap;
_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- data_.Swap(&other->data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ logdata_.Swap(&other->logdata_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ swap(authenticationdata_, other->authenticationdata_);
}
::PROTOBUF_NAMESPACE_ID::Metadata SendLogRequest::GetMetadata() const {
@@ -738,91 +3888,81 @@
// ===================================================================
-class PullBackupKeyRequest::_Internal {
+class RecoverBackupKeyRequest::_Internal {
public:
+ static const ::backup::FullAuthenticationRequestData& authenticationdata(const RecoverBackupKeyRequest* msg);
};
-PullBackupKeyRequest::PullBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::FullAuthenticationRequestData&
+RecoverBackupKeyRequest::_Internal::authenticationdata(const RecoverBackupKeyRequest* msg) {
+ return *msg->authenticationdata_;
+}
+RecoverBackupKeyRequest::RecoverBackupKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyRequest)
}
-PullBackupKeyRequest::PullBackupKeyRequest(const PullBackupKeyRequest& from)
+RecoverBackupKeyRequest::RecoverBackupKeyRequest(const RecoverBackupKeyRequest& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userid().empty()) {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
- GetArena());
- }
- pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_pakekey().empty()) {
- pakekey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakekey(),
- GetArena());
+ if (from._internal_has_authenticationdata()) {
+ authenticationdata_ = new ::backup::FullAuthenticationRequestData(*from.authenticationdata_);
+ } else {
+ authenticationdata_ = nullptr;
}
- // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyRequest)
}
-void PullBackupKeyRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-pakekey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void RecoverBackupKeyRequest::SharedCtor() {
+authenticationdata_ = nullptr;
}
-PullBackupKeyRequest::~PullBackupKeyRequest() {
- // @@protoc_insertion_point(destructor:backup.PullBackupKeyRequest)
+RecoverBackupKeyRequest::~RecoverBackupKeyRequest() {
+ // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyRequest)
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-void PullBackupKeyRequest::SharedDtor() {
+void RecoverBackupKeyRequest::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- pakekey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete authenticationdata_;
}
-void PullBackupKeyRequest::ArenaDtor(void* object) {
- PullBackupKeyRequest* _this = reinterpret_cast< PullBackupKeyRequest* >(object);
+void RecoverBackupKeyRequest::ArenaDtor(void* object) {
+ RecoverBackupKeyRequest* _this = reinterpret_cast< RecoverBackupKeyRequest* >(object);
(void)_this;
}
-void PullBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void RecoverBackupKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
-void PullBackupKeyRequest::SetCachedSize(int size) const {
+void RecoverBackupKeyRequest::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-void PullBackupKeyRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyRequest)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- userid_.ClearToEmpty();
- pakekey_.ClearToEmpty();
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-const char* PullBackupKeyRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* RecoverBackupKeyRequest::_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;
+ // .backup.FullAuthenticationRequestData authenticationData = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_userid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullBackupKeyRequest.userId"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes pakeKey = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_pakekey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
@@ -848,56 +3988,41 @@
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyRequest::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyRequest)
::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.PullBackupKeyRequest.userId");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // bytes pakeKey = 2;
- if (this->pakekey().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_pakekey(), target);
+ // .backup.FullAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationdata(this), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
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.PullBackupKeyRequest)
+ // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyRequest)
return target;
}
-size_t PullBackupKeyRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyRequest)
+size_t RecoverBackupKeyRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyRequest)
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());
- }
-
- // bytes pakeKey = 2;
- if (this->pakekey().size() > 0) {
+ // .backup.FullAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakekey());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *authenticationdata_);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -909,136 +4034,229 @@
return total_size;
}
-void PullBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyRequest)
GOOGLE_DCHECK_NE(&from, this);
- const PullBackupKeyRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyRequest>(
+ const RecoverBackupKeyRequest* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyRequest>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyRequest)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyRequest)
MergeFrom(*source);
}
}
-void PullBackupKeyRequest::MergeFrom(const PullBackupKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::MergeFrom(const RecoverBackupKeyRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyRequest)
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.pakekey().size() > 0) {
- _internal_set_pakekey(from._internal_pakekey());
+ if (from.has_authenticationdata()) {
+ _internal_mutable_authenticationdata()->::backup::FullAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
}
}
-void PullBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void PullBackupKeyRequest::CopyFrom(const PullBackupKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyRequest)
+void RecoverBackupKeyRequest::CopyFrom(const RecoverBackupKeyRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool PullBackupKeyRequest::IsInitialized() const {
+bool RecoverBackupKeyRequest::IsInitialized() const {
return true;
}
-void PullBackupKeyRequest::InternalSwap(PullBackupKeyRequest* other) {
+void RecoverBackupKeyRequest::InternalSwap(RecoverBackupKeyRequest* other) {
using std::swap;
_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- pakekey_.Swap(&other->pakekey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ swap(authenticationdata_, other->authenticationdata_);
}
-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyRequest::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
-class PullBackupKeyResponse::_Internal {
+class RecoverBackupKeyResponse::_Internal {
public:
+ static const ::backup::FullAuthenticationResponseData& authenticationresponsedata(const RecoverBackupKeyResponse* msg);
+ static const ::backup::BackupKeyEntropy& backupkeyentropy(const RecoverBackupKeyResponse* msg);
};
-PullBackupKeyResponse::PullBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::FullAuthenticationResponseData&
+RecoverBackupKeyResponse::_Internal::authenticationresponsedata(const RecoverBackupKeyResponse* msg) {
+ return *msg->data_.authenticationresponsedata_;
+}
+const ::backup::BackupKeyEntropy&
+RecoverBackupKeyResponse::_Internal::backupkeyentropy(const RecoverBackupKeyResponse* msg) {
+ return *msg->data_.backupkeyentropy_;
+}
+void RecoverBackupKeyResponse::set_allocated_authenticationresponsedata(::backup::FullAuthenticationResponseData* authenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (authenticationresponsedata) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(authenticationresponsedata);
+ if (message_arena != submessage_arena) {
+ authenticationresponsedata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, authenticationresponsedata, submessage_arena);
+ }
+ set_has_authenticationresponsedata();
+ data_.authenticationresponsedata_ = authenticationresponsedata;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.authenticationResponseData)
+}
+void RecoverBackupKeyResponse::set_allocated_backupkeyentropy(::backup::BackupKeyEntropy* backupkeyentropy) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+ clear_data();
+ if (backupkeyentropy) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(backupkeyentropy);
+ if (message_arena != submessage_arena) {
+ backupkeyentropy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, backupkeyentropy, submessage_arena);
+ }
+ set_has_backupkeyentropy();
+ data_.backupkeyentropy_ = backupkeyentropy;
+ }
+ // @@protoc_insertion_point(field_set_allocated:backup.RecoverBackupKeyResponse.backupKeyEntropy)
+}
+RecoverBackupKeyResponse::RecoverBackupKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(arena_constructor:backup.RecoverBackupKeyResponse)
}
-PullBackupKeyResponse::PullBackupKeyResponse(const PullBackupKeyResponse& from)
+RecoverBackupKeyResponse::RecoverBackupKeyResponse(const RecoverBackupKeyResponse& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_encryptedbackupkey().empty()) {
- encryptedbackupkey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_encryptedbackupkey(),
- GetArena());
+ clear_has_data();
+ switch (from.data_case()) {
+ case kAuthenticationResponseData: {
+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
+ break;
+ }
+ case kBackupKeyEntropy: {
+ _internal_mutable_backupkeyentropy()->::backup::BackupKeyEntropy::MergeFrom(from._internal_backupkeyentropy());
+ break;
+ }
+ case kBackupID: {
+ _internal_set_backupid(from._internal_backupid());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
}
- // @@protoc_insertion_point(copy_constructor:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(copy_constructor:backup.RecoverBackupKeyResponse)
}
-void PullBackupKeyResponse::SharedCtor() {
-encryptedbackupkey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void RecoverBackupKeyResponse::SharedCtor() {
+clear_has_data();
}
-PullBackupKeyResponse::~PullBackupKeyResponse() {
- // @@protoc_insertion_point(destructor:backup.PullBackupKeyResponse)
+RecoverBackupKeyResponse::~RecoverBackupKeyResponse() {
+ // @@protoc_insertion_point(destructor:backup.RecoverBackupKeyResponse)
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-void PullBackupKeyResponse::SharedDtor() {
+void RecoverBackupKeyResponse::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
- encryptedbackupkey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (has_data()) {
+ clear_data();
+ }
}
-void PullBackupKeyResponse::ArenaDtor(void* object) {
- PullBackupKeyResponse* _this = reinterpret_cast< PullBackupKeyResponse* >(object);
+void RecoverBackupKeyResponse::ArenaDtor(void* object) {
+ RecoverBackupKeyResponse* _this = reinterpret_cast< RecoverBackupKeyResponse* >(object);
(void)_this;
}
-void PullBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void RecoverBackupKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
-void PullBackupKeyResponse::SetCachedSize(int size) const {
+void RecoverBackupKeyResponse::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-void PullBackupKeyResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.RecoverBackupKeyResponse)
+ switch (data_case()) {
+ case kAuthenticationResponseData: {
+ if (GetArena() == nullptr) {
+ delete data_.authenticationresponsedata_;
+ }
+ break;
+ }
+ case kBackupKeyEntropy: {
+ if (GetArena() == nullptr) {
+ delete data_.backupkeyentropy_;
+ }
+ break;
+ }
+ case kBackupID: {
+ data_.backupid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = DATA_NOT_SET;
+}
+
+
+void RecoverBackupKeyResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.RecoverBackupKeyResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- encryptedbackupkey_.ClearToEmpty();
+ clear_data();
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-const char* PullBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* RecoverBackupKeyResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
- // bytes encryptedBackupKey = 1;
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_encryptedbackupkey();
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationresponsedata(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_backupkeyentropy(), ptr);
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string backupID = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ auto str = _internal_mutable_backupid();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.RecoverBackupKeyResponse.backupID"));
CHK_(ptr);
} else goto handle_unusual;
continue;
@@ -1064,41 +4282,80 @@
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* PullBackupKeyResponse::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* RecoverBackupKeyResponse::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(serialize_to_array_start:backup.RecoverBackupKeyResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
- // bytes encryptedBackupKey = 1;
- if (this->encryptedbackupkey().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 1, this->_internal_encryptedbackupkey(), target);
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ if (_internal_has_authenticationresponsedata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationresponsedata(this), target, stream);
+ }
+
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ if (_internal_has_backupkeyentropy()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::backupkeyentropy(this), target, stream);
+ }
+
+ // string backupID = 4;
+ if (_internal_has_backupid()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_backupid().data(), static_cast<int>(this->_internal_backupid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "backup.RecoverBackupKeyResponse.backupID");
+ target = stream->WriteStringMaybeAliased(
+ 4, this->_internal_backupid(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
}
- // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(serialize_to_array_end:backup.RecoverBackupKeyResponse)
return target;
}
-size_t PullBackupKeyResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupKeyResponse)
+size_t RecoverBackupKeyResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.RecoverBackupKeyResponse)
size_t total_size = 0;
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- // bytes encryptedBackupKey = 1;
- if (this->encryptedbackupkey().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_encryptedbackupkey());
+ switch (data_case()) {
+ // .backup.FullAuthenticationResponseData authenticationResponseData = 1;
+ case kAuthenticationResponseData: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.authenticationresponsedata_);
+ break;
+ }
+ // .backup.BackupKeyEntropy backupKeyEntropy = 2;
+ case kBackupKeyEntropy: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *data_.backupkeyentropy_);
+ break;
+ }
+ // string backupID = 4;
+ case kBackupID: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_backupid());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
}
-
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
_internal_metadata_, total_size, &_cached_size_);
@@ -1108,149 +4365,154 @@
return total_size;
}
-void PullBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.RecoverBackupKeyResponse)
GOOGLE_DCHECK_NE(&from, this);
- const PullBackupKeyResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupKeyResponse>(
+ const RecoverBackupKeyResponse* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RecoverBackupKeyResponse>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.RecoverBackupKeyResponse)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupKeyResponse)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.RecoverBackupKeyResponse)
MergeFrom(*source);
}
}
-void PullBackupKeyResponse::MergeFrom(const PullBackupKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::MergeFrom(const RecoverBackupKeyResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.RecoverBackupKeyResponse)
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.encryptedbackupkey().size() > 0) {
- _internal_set_encryptedbackupkey(from._internal_encryptedbackupkey());
+ switch (from.data_case()) {
+ case kAuthenticationResponseData: {
+ _internal_mutable_authenticationresponsedata()->::backup::FullAuthenticationResponseData::MergeFrom(from._internal_authenticationresponsedata());
+ break;
+ }
+ case kBackupKeyEntropy: {
+ _internal_mutable_backupkeyentropy()->::backup::BackupKeyEntropy::MergeFrom(from._internal_backupkeyentropy());
+ break;
+ }
+ case kBackupID: {
+ _internal_set_backupid(from._internal_backupid());
+ break;
+ }
+ case DATA_NOT_SET: {
+ break;
+ }
}
}
-void PullBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.RecoverBackupKeyResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void PullBackupKeyResponse::CopyFrom(const PullBackupKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupKeyResponse)
+void RecoverBackupKeyResponse::CopyFrom(const RecoverBackupKeyResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.RecoverBackupKeyResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool PullBackupKeyResponse::IsInitialized() const {
+bool RecoverBackupKeyResponse::IsInitialized() const {
return true;
}
-void PullBackupKeyResponse::InternalSwap(PullBackupKeyResponse* other) {
+void RecoverBackupKeyResponse::InternalSwap(RecoverBackupKeyResponse* other) {
using std::swap;
_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- encryptedbackupkey_.Swap(&other->encryptedbackupkey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ swap(data_, other->data_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
}
-::PROTOBUF_NAMESPACE_ID::Metadata PullBackupKeyResponse::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata RecoverBackupKeyResponse::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
-class PullCompactionRequest::_Internal {
+class PullBackupRequest::_Internal {
public:
+ static const ::backup::SimpleAuthenticationRequestData& authenticationdata(const PullBackupRequest* msg);
};
-PullCompactionRequest::PullCompactionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+const ::backup::SimpleAuthenticationRequestData&
+PullBackupRequest::_Internal::authenticationdata(const PullBackupRequest* msg) {
+ return *msg->authenticationdata_;
+}
+PullBackupRequest::PullBackupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(arena_constructor:backup.PullBackupRequest)
}
-PullCompactionRequest::PullCompactionRequest(const PullCompactionRequest& from)
+PullBackupRequest::PullBackupRequest(const PullBackupRequest& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userid().empty()) {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
- GetArena());
- }
- message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_message().empty()) {
- message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(),
- GetArena());
+ if (from._internal_has_authenticationdata()) {
+ authenticationdata_ = new ::backup::SimpleAuthenticationRequestData(*from.authenticationdata_);
+ } else {
+ authenticationdata_ = nullptr;
}
- // @@protoc_insertion_point(copy_constructor:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(copy_constructor:backup.PullBackupRequest)
}
-void PullCompactionRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+void PullBackupRequest::SharedCtor() {
+authenticationdata_ = nullptr;
}
-PullCompactionRequest::~PullCompactionRequest() {
- // @@protoc_insertion_point(destructor:backup.PullCompactionRequest)
+PullBackupRequest::~PullBackupRequest() {
+ // @@protoc_insertion_point(destructor:backup.PullBackupRequest)
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-void PullCompactionRequest::SharedDtor() {
+void PullBackupRequest::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (this != internal_default_instance()) delete authenticationdata_;
}
-void PullCompactionRequest::ArenaDtor(void* object) {
- PullCompactionRequest* _this = reinterpret_cast< PullCompactionRequest* >(object);
+void PullBackupRequest::ArenaDtor(void* object) {
+ PullBackupRequest* _this = reinterpret_cast< PullBackupRequest* >(object);
(void)_this;
}
-void PullCompactionRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void PullBackupRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
-void PullCompactionRequest::SetCachedSize(int size) const {
+void PullBackupRequest::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-void PullCompactionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionRequest)
+void PullBackupRequest::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PullBackupRequest)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
- userid_.ClearToEmpty();
- message_.ClearToEmpty();
+ if (GetArena() == nullptr && authenticationdata_ != nullptr) {
+ delete authenticationdata_;
+ }
+ authenticationdata_ = nullptr;
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-const char* PullCompactionRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* PullBackupRequest::_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;
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_userid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "backup.PullCompactionRequest.userId"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes message = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_message();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ ptr = ctx->ParseMessage(_internal_mutable_authenticationdata(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
@@ -1276,56 +4538,41 @@
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionRequest::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupRequest::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupRequest)
::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.PullCompactionRequest.userId");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // bytes message = 2;
- if (this->message().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_message(), target);
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::authenticationdata(this), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
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.PullCompactionRequest)
+ // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupRequest)
return target;
}
-size_t PullCompactionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionRequest)
+size_t PullBackupRequest::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupRequest)
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());
- }
-
- // bytes message = 2;
- if (this->message().size() > 0) {
+ // .backup.SimpleAuthenticationRequestData authenticationData = 1;
+ if (this->has_authenticationdata()) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_message());
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *authenticationdata_);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
@@ -1337,79 +4584,75 @@
return total_size;
}
-void PullCompactionRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupRequest)
GOOGLE_DCHECK_NE(&from, this);
- const PullCompactionRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionRequest>(
+ const PullBackupRequest* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupRequest>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupRequest)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionRequest)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupRequest)
MergeFrom(*source);
}
}
-void PullCompactionRequest::MergeFrom(const PullCompactionRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::MergeFrom(const PullBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupRequest)
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.message().size() > 0) {
- _internal_set_message(from._internal_message());
+ if (from.has_authenticationdata()) {
+ _internal_mutable_authenticationdata()->::backup::SimpleAuthenticationRequestData::MergeFrom(from._internal_authenticationdata());
}
}
-void PullCompactionRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void PullCompactionRequest::CopyFrom(const PullCompactionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionRequest)
+void PullBackupRequest::CopyFrom(const PullBackupRequest& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool PullCompactionRequest::IsInitialized() const {
+bool PullBackupRequest::IsInitialized() const {
return true;
}
-void PullCompactionRequest::InternalSwap(PullCompactionRequest* other) {
+void PullBackupRequest::InternalSwap(PullBackupRequest* other) {
using std::swap;
_internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- message_.Swap(&other->message_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ swap(authenticationdata_, other->authenticationdata_);
}
-::PROTOBUF_NAMESPACE_ID::Metadata PullCompactionRequest::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupRequest::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
-class PullCompactionResponse::_Internal {
+class PullBackupResponse::_Internal {
public:
};
-PullCompactionResponse::PullCompactionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+PullBackupResponse::PullBackupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
: ::PROTOBUF_NAMESPACE_ID::Message(arena) {
SharedCtor();
RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(arena_constructor:backup.PullBackupResponse)
}
-PullCompactionResponse::PullCompactionResponse(const PullCompactionResponse& from)
+PullBackupResponse::PullBackupResponse(const PullBackupResponse& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
clear_has_data();
@@ -1426,38 +4669,38 @@
break;
}
}
- // @@protoc_insertion_point(copy_constructor:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(copy_constructor:backup.PullBackupResponse)
}
-void PullCompactionResponse::SharedCtor() {
+void PullBackupResponse::SharedCtor() {
clear_has_data();
}
-PullCompactionResponse::~PullCompactionResponse() {
- // @@protoc_insertion_point(destructor:backup.PullCompactionResponse)
+PullBackupResponse::~PullBackupResponse() {
+ // @@protoc_insertion_point(destructor:backup.PullBackupResponse)
SharedDtor();
_internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-void PullCompactionResponse::SharedDtor() {
+void PullBackupResponse::SharedDtor() {
GOOGLE_DCHECK(GetArena() == nullptr);
if (has_data()) {
clear_data();
}
}
-void PullCompactionResponse::ArenaDtor(void* object) {
- PullCompactionResponse* _this = reinterpret_cast< PullCompactionResponse* >(object);
+void PullBackupResponse::ArenaDtor(void* object) {
+ PullBackupResponse* _this = reinterpret_cast< PullBackupResponse* >(object);
(void)_this;
}
-void PullCompactionResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+void PullBackupResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
-void PullCompactionResponse::SetCachedSize(int size) const {
+void PullBackupResponse::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
-void PullCompactionResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:backup.PullCompactionResponse)
+void PullBackupResponse::clear_data() {
+// @@protoc_insertion_point(one_of_clear_start:backup.PullBackupResponse)
switch (data_case()) {
case kCompactionChunk: {
data_.compactionchunk_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
@@ -1475,8 +4718,8 @@
}
-void PullCompactionResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:backup.PullCompactionResponse)
+void PullBackupResponse::Clear() {
+// @@protoc_insertion_point(message_clear_start:backup.PullBackupResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
@@ -1485,7 +4728,7 @@
_internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
-const char* PullCompactionResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+const char* PullBackupResponse::_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;
@@ -1530,9 +4773,9 @@
#undef CHK_
}
-::PROTOBUF_NAMESPACE_ID::uint8* PullCompactionResponse::_InternalSerialize(
+::PROTOBUF_NAMESPACE_ID::uint8* PullBackupResponse::_InternalSerialize(
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(serialize_to_array_start:backup.PullBackupResponse)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
@@ -1552,12 +4795,12 @@
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.PullCompactionResponse)
+ // @@protoc_insertion_point(serialize_to_array_end:backup.PullBackupResponse)
return target;
}
-size_t PullCompactionResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:backup.PullCompactionResponse)
+size_t PullBackupResponse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:backup.PullBackupResponse)
size_t total_size = 0;
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
@@ -1592,23 +4835,23 @@
return total_size;
}
-void PullCompactionResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:backup.PullBackupResponse)
GOOGLE_DCHECK_NE(&from, this);
- const PullCompactionResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullCompactionResponse>(
+ const PullBackupResponse* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PullBackupResponse>(
&from);
if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:backup.PullBackupResponse)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullCompactionResponse)
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:backup.PullBackupResponse)
MergeFrom(*source);
}
}
-void PullCompactionResponse::MergeFrom(const PullCompactionResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::MergeFrom(const PullBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:backup.PullBackupResponse)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
@@ -1629,32 +4872,32 @@
}
}
-void PullCompactionResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:backup.PullBackupResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-void PullCompactionResponse::CopyFrom(const PullCompactionResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullCompactionResponse)
+void PullBackupResponse::CopyFrom(const PullBackupResponse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:backup.PullBackupResponse)
if (&from == this) return;
Clear();
MergeFrom(from);
}
-bool PullCompactionResponse::IsInitialized() const {
+bool PullBackupResponse::IsInitialized() const {
return true;
}
-void PullCompactionResponse::InternalSwap(PullCompactionResponse* other) {
+void PullBackupResponse::InternalSwap(PullBackupResponse* 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 PullCompactionResponse::GetMetadata() const {
+::PROTOBUF_NAMESPACE_ID::Metadata PullBackupResponse::GetMetadata() const {
return GetMetadataStatic();
}
@@ -1662,23 +4905,53 @@
// @@protoc_insertion_point(namespace_scope)
} // namespace backup
PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::backup::ResetKeyRequest* Arena::CreateMaybeMessage< ::backup::ResetKeyRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::backup::ResetKeyRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage< ::backup::PakeRegistrationRequestAndUserID >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::PakeRegistrationRequestAndUserID >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::PakeAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::PakeAuthenticationRequestData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::PakeAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::WalletAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::WalletAuthenticationRequestData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::WalletAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationRequestData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::FullAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::WalletAuthenticationResponseData* Arena::CreateMaybeMessage< ::backup::WalletAuthenticationResponseData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::WalletAuthenticationResponseData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::PakeAuthenticationResponseData* Arena::CreateMaybeMessage< ::backup::PakeAuthenticationResponseData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::PakeAuthenticationResponseData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::FullAuthenticationResponseData* Arena::CreateMaybeMessage< ::backup::FullAuthenticationResponseData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::FullAuthenticationResponseData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::SimpleAuthenticationRequestData* Arena::CreateMaybeMessage< ::backup::SimpleAuthenticationRequestData >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::SimpleAuthenticationRequestData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::BackupKeyEntropy* Arena::CreateMaybeMessage< ::backup::BackupKeyEntropy >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::BackupKeyEntropy >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupRequest* Arena::CreateMaybeMessage< ::backup::CreateNewBackupRequest >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::CreateNewBackupRequest >(arena);
+}
+template<> PROTOBUF_NOINLINE ::backup::CreateNewBackupResponse* Arena::CreateMaybeMessage< ::backup::CreateNewBackupResponse >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::CreateNewBackupResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::backup::SendLogRequest* Arena::CreateMaybeMessage< ::backup::SendLogRequest >(Arena* arena) {
return Arena::CreateMessageInternal< ::backup::SendLogRequest >(arena);
}
-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::PullBackupKeyRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::backup::PullBackupKeyRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyRequest* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyRequest >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyRequest >(arena);
}
-template<> PROTOBUF_NOINLINE ::backup::PullBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::PullBackupKeyResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::backup::PullBackupKeyResponse >(arena);
+template<> PROTOBUF_NOINLINE ::backup::RecoverBackupKeyResponse* Arena::CreateMaybeMessage< ::backup::RecoverBackupKeyResponse >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::RecoverBackupKeyResponse >(arena);
}
-template<> PROTOBUF_NOINLINE ::backup::PullCompactionRequest* Arena::CreateMaybeMessage< ::backup::PullCompactionRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::backup::PullCompactionRequest >(arena);
+template<> PROTOBUF_NOINLINE ::backup::PullBackupRequest* Arena::CreateMaybeMessage< ::backup::PullBackupRequest >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::PullBackupRequest >(arena);
}
-template<> PROTOBUF_NOINLINE ::backup::PullCompactionResponse* Arena::CreateMaybeMessage< ::backup::PullCompactionResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::backup::PullCompactionResponse >(arena);
+template<> PROTOBUF_NOINLINE ::backup::PullBackupResponse* Arena::CreateMaybeMessage< ::backup::PullBackupResponse >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::backup::PullBackupResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.h
@@ -92,6 +92,16 @@
std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
}
+ // Replacing Send and Get with a single bidirectional streaming RPC
+ std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
+ }
class async_interface {
public:
virtual ~async_interface() {}
@@ -114,6 +124,8 @@
virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) = 0;
virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0;
virtual void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) = 0;
+ // Replacing Send and Get with a single bidirectional streaming RPC
+ virtual void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) = 0;
};
typedef class async_interface experimental_async_interface;
virtual class async_interface* async() { return nullptr; }
@@ -134,6 +146,9 @@
virtual ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) = 0;
virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) = 0;
+ virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
+ virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
};
class Stub final : public StubInterface {
public:
@@ -189,6 +204,15 @@
std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq));
}
+ std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> OpenStream(::grpc::ClientContext* context) {
+ return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(OpenStreamRaw(context));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> AsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(AsyncOpenStreamRaw(context, cq, tag));
+ }
+ std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>> PrepareAsyncOpenStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>>(PrepareAsyncOpenStreamRaw(context, cq));
+ }
class async final :
public StubInterface::async_interface {
public:
@@ -205,6 +229,7 @@
void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function<void(::grpc::Status)>) override;
void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override;
void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) override;
+ void OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) override;
private:
friend class Stub;
explicit async(Stub* stub): stub_(stub) { }
@@ -231,6 +256,9 @@
::grpc::ClientReader< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) override;
::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) override;
::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) override;
+ ::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStreamRaw(::grpc::ClientContext* context) override;
+ ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
+ ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
const ::grpc::internal::RpcMethod rpcmethod_CheckIfPrimaryDeviceOnline_;
const ::grpc::internal::RpcMethod rpcmethod_BecomeNewPrimaryDevice_;
const ::grpc::internal::RpcMethod rpcmethod_SendPong_;
@@ -238,6 +266,7 @@
const ::grpc::internal::RpcMethod rpcmethod_NewSession_;
const ::grpc::internal::RpcMethod rpcmethod_Send_;
const ::grpc::internal::RpcMethod rpcmethod_Get_;
+ const ::grpc::internal::RpcMethod rpcmethod_OpenStream_;
};
static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
@@ -258,6 +287,8 @@
virtual ::grpc::Status NewSession(::grpc::ServerContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response);
virtual ::grpc::Status Send(::grpc::ServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response);
virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* writer);
+ // Replacing Send and Get with a single bidirectional streaming RPC
+ virtual ::grpc::Status OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream);
};
template <class BaseClass>
class WithAsyncMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
@@ -399,7 +430,27 @@
::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag);
}
};
- typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<Service > > > > > > > AsyncService;
+ template <class BaseClass>
+ class WithAsyncMethod_OpenStream : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithAsyncMethod_OpenStream() {
+ ::grpc::Service::MarkMethodAsync(7);
+ }
+ ~WithAsyncMethod_OpenStream() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
+ }
+ };
+ typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline<WithAsyncMethod_BecomeNewPrimaryDevice<WithAsyncMethod_SendPong<WithAsyncMethod_SessionSignature<WithAsyncMethod_NewSession<WithAsyncMethod_Send<WithAsyncMethod_Get<WithAsyncMethod_OpenStream<Service > > > > > > > > AsyncService;
template <class BaseClass>
class WithCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
private:
@@ -584,7 +635,30 @@
virtual ::grpc::ServerWriteReactor< ::tunnelbroker::GetResponse>* Get(
::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/) { return nullptr; }
};
- typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<Service > > > > > > > CallbackService;
+ template <class BaseClass>
+ class WithCallbackMethod_OpenStream : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithCallbackMethod_OpenStream() {
+ ::grpc::Service::MarkMethodCallback(7,
+ new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
+ [this](
+ ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
+ }
+ ~WithCallbackMethod_OpenStream() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ virtual ::grpc::ServerBidiReactor< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* OpenStream(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
+ };
+ typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline<WithCallbackMethod_BecomeNewPrimaryDevice<WithCallbackMethod_SendPong<WithCallbackMethod_SessionSignature<WithCallbackMethod_NewSession<WithCallbackMethod_Send<WithCallbackMethod_Get<WithCallbackMethod_OpenStream<Service > > > > > > > > CallbackService;
typedef CallbackService ExperimentalCallbackService;
template <class BaseClass>
class WithGenericMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
@@ -706,6 +780,23 @@
}
};
template <class BaseClass>
+ class WithGenericMethod_OpenStream : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithGenericMethod_OpenStream() {
+ ::grpc::Service::MarkMethodGeneric(7);
+ }
+ ~WithGenericMethod_OpenStream() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ };
+ template <class BaseClass>
class WithRawMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -846,6 +937,26 @@
}
};
template <class BaseClass>
+ class WithRawMethod_OpenStream : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithRawMethod_OpenStream() {
+ ::grpc::Service::MarkMethodRaw(7);
+ }
+ ~WithRawMethod_OpenStream() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ void RequestOpenStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+ ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag);
+ }
+ };
+ template <class BaseClass>
class WithRawCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -1000,6 +1111,29 @@
::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; }
};
template <class BaseClass>
+ class WithRawCallbackMethod_OpenStream : public BaseClass {
+ private:
+ void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+ public:
+ WithRawCallbackMethod_OpenStream() {
+ ::grpc::Service::MarkMethodRawCallback(7,
+ new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+ [this](
+ ::grpc::CallbackServerContext* context) { return this->OpenStream(context); }));
+ }
+ ~WithRawCallbackMethod_OpenStream() override {
+ BaseClassMustBeDerivedFromService(this);
+ }
+ // disable synchronous version of this method
+ ::grpc::Status OpenStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* /*stream*/) override {
+ abort();
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+ }
+ virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* OpenStream(
+ ::grpc::CallbackServerContext* /*context*/)
+ { return nullptr; }
+ };
+ template <class BaseClass>
class WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.grpc.pb.cc
@@ -29,6 +29,7 @@
"/tunnelbroker.TunnelbrokerService/NewSession",
"/tunnelbroker.TunnelbrokerService/Send",
"/tunnelbroker.TunnelbrokerService/Get",
+ "/tunnelbroker.TunnelbrokerService/OpenStream",
};
std::unique_ptr< TunnelbrokerService::Stub> TunnelbrokerService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
@@ -45,6 +46,7 @@
, rpcmethod_NewSession_(TunnelbrokerService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_Send_(TunnelbrokerService_method_names[5], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_Get_(TunnelbrokerService_method_names[6], options.suffix_for_stats(),::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
+ , rpcmethod_OpenStream_(TunnelbrokerService_method_names[7], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
{}
::grpc::Status TunnelbrokerService::Stub::CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) {
@@ -201,6 +203,22 @@
return ::grpc::internal::ClientAsyncReaderFactory< ::tunnelbroker::GetResponse>::Create(channel_.get(), cq, rpcmethod_Get_, context, request, false, nullptr);
}
+::grpc::ClientReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::OpenStreamRaw(::grpc::ClientContext* context) {
+ return ::grpc::internal::ClientReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), rpcmethod_OpenStream_, context);
+}
+
+void TunnelbrokerService::Stub::async::OpenStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>* reactor) {
+ ::grpc::internal::ClientCallbackReaderWriterFactory< ::tunnelbroker::OutboundMessage,::tunnelbroker::InboundMessage>::Create(stub_->channel_.get(), stub_->rpcmethod_OpenStream_, context, reactor);
+}
+
+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::AsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, true, tag);
+}
+
+::grpc::ClientAsyncReaderWriter< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>* TunnelbrokerService::Stub::PrepareAsyncOpenStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
+ return ::grpc::internal::ClientAsyncReaderWriterFactory< ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>::Create(channel_.get(), cq, rpcmethod_OpenStream_, context, false, nullptr);
+}
+
TunnelbrokerService::Service::Service() {
AddMethod(new ::grpc::internal::RpcServiceMethod(
TunnelbrokerService_method_names[0],
@@ -272,6 +290,16 @@
::grpc::ServerWriter<::tunnelbroker::GetResponse>* writer) {
return service->Get(ctx, req, writer);
}, this)));
+ AddMethod(new ::grpc::internal::RpcServiceMethod(
+ TunnelbrokerService_method_names[7],
+ ::grpc::internal::RpcMethod::BIDI_STREAMING,
+ new ::grpc::internal::BidiStreamingHandler< TunnelbrokerService::Service, ::tunnelbroker::OutboundMessage, ::tunnelbroker::InboundMessage>(
+ [](TunnelbrokerService::Service* service,
+ ::grpc::ServerContext* ctx,
+ ::grpc::ServerReaderWriter<::tunnelbroker::InboundMessage,
+ ::tunnelbroker::OutboundMessage>* stream) {
+ return service->OpenStream(ctx, stream);
+ }, this)));
}
TunnelbrokerService::Service::~Service() {
@@ -326,6 +354,12 @@
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
+::grpc::Status TunnelbrokerService::Service::OpenStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::InboundMessage, ::tunnelbroker::OutboundMessage>* stream) {
+ (void) context;
+ (void) stream;
+ return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
} // namespace tunnelbroker
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.h
@@ -48,7 +48,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[12]
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -69,6 +69,9 @@
class GetResponse;
struct GetResponseDefaultTypeInternal;
extern GetResponseDefaultTypeInternal _GetResponse_default_instance_;
+class InboundMessage;
+struct InboundMessageDefaultTypeInternal;
+extern InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
class NewPrimaryRequest;
struct NewPrimaryRequestDefaultTypeInternal;
extern NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_;
@@ -81,6 +84,9 @@
class NewSessionResponse;
struct NewSessionResponseDefaultTypeInternal;
extern NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_;
+class OutboundMessage;
+struct OutboundMessageDefaultTypeInternal;
+extern OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
class PongRequest;
struct PongRequestDefaultTypeInternal;
extern PongRequestDefaultTypeInternal _PongRequest_default_instance_;
@@ -99,10 +105,12 @@
template<> ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage<::tunnelbroker::CheckResponse>(Arena*);
template<> ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage<::tunnelbroker::GetRequest>(Arena*);
template<> ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage<::tunnelbroker::GetResponse>(Arena*);
+template<> ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::InboundMessage>(Arena*);
template<> ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryRequest>(Arena*);
template<> ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryResponse>(Arena*);
template<> ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionRequest>(Arena*);
template<> ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionResponse>(Arena*);
+template<> ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage<::tunnelbroker::OutboundMessage>(Arena*);
template<> ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage<::tunnelbroker::PongRequest>(Arena*);
template<> ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage<::tunnelbroker::SendRequest>(Arena*);
template<> ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureRequest>(Arena*);
@@ -622,13 +630,13 @@
std::string* _internal_mutable_deviceid();
public:
- // bytes publicKey = 2;
+ // string publicKey = 2;
void clear_publickey();
const std::string& publickey() const;
void set_publickey(const std::string& value);
void set_publickey(std::string&& value);
void set_publickey(const char* value);
- void set_publickey(const void* value, size_t size);
+ void set_publickey(const char* value, size_t size);
std::string* mutable_publickey();
std::string* release_publickey();
void set_allocated_publickey(std::string* publickey);
@@ -1417,24 +1425,24 @@
};
// -------------------------------------------------------------------
-class CheckRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
+class OutboundMessage PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.OutboundMessage) */ {
public:
- inline CheckRequest() : CheckRequest(nullptr) {}
- virtual ~CheckRequest();
- explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline OutboundMessage() : OutboundMessage(nullptr) {}
+ virtual ~OutboundMessage();
+ explicit constexpr OutboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- CheckRequest(const CheckRequest& from);
- CheckRequest(CheckRequest&& from) noexcept
- : CheckRequest() {
+ OutboundMessage(const OutboundMessage& from);
+ OutboundMessage(OutboundMessage&& from) noexcept
+ : OutboundMessage() {
*this = ::std::move(from);
}
- inline CheckRequest& operator=(const CheckRequest& from) {
+ inline OutboundMessage& operator=(const OutboundMessage& from) {
CopyFrom(from);
return *this;
}
- inline CheckRequest& operator=(CheckRequest&& from) noexcept {
+ inline OutboundMessage& operator=(OutboundMessage&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -1452,20 +1460,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const CheckRequest& default_instance() {
+ static const OutboundMessage& default_instance() {
return *internal_default_instance();
}
- static inline const CheckRequest* internal_default_instance() {
- return reinterpret_cast<const CheckRequest*>(
- &_CheckRequest_default_instance_);
+ static inline const OutboundMessage* internal_default_instance() {
+ return reinterpret_cast<const OutboundMessage*>(
+ &_OutboundMessage_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
- friend void swap(CheckRequest& a, CheckRequest& b) {
+ friend void swap(OutboundMessage& a, OutboundMessage& b) {
a.Swap(&b);
}
- inline void Swap(CheckRequest* other) {
+ inline void Swap(OutboundMessage* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -1473,7 +1481,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(CheckRequest* other) {
+ void UnsafeArenaSwap(OutboundMessage* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -1481,17 +1489,17 @@
// implements Message ----------------------------------------------
- inline CheckRequest* New() const final {
- return CreateMaybeMessage<CheckRequest>(nullptr);
+ inline OutboundMessage* New() const final {
+ return CreateMaybeMessage<OutboundMessage>(nullptr);
}
- CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<CheckRequest>(arena);
+ OutboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<OutboundMessage>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const CheckRequest& from);
- void MergeFrom(const CheckRequest& from);
+ void CopyFrom(const OutboundMessage& from);
+ void MergeFrom(const OutboundMessage& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -1505,13 +1513,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(CheckRequest* other);
+ void InternalSwap(OutboundMessage* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "tunnelbroker.CheckRequest";
+ return "tunnelbroker.OutboundMessage";
}
protected:
- explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1530,73 +1538,99 @@
// accessors -------------------------------------------------------
enum : int {
- kUserIdFieldNumber = 1,
- kDeviceTokenFieldNumber = 2,
+ kBlobHashesFieldNumber = 3,
+ kToDeviceIDFieldNumber = 1,
+ kPayloadFieldNumber = 2,
};
- // 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);
+ // repeated string blobHashes = 3;
+ int blobhashes_size() const;
private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
+ int _internal_blobhashes_size() const;
+ public:
+ void clear_blobhashes();
+ const std::string& blobhashes(int index) const;
+ std::string* mutable_blobhashes(int index);
+ void set_blobhashes(int index, const std::string& value);
+ void set_blobhashes(int index, std::string&& value);
+ void set_blobhashes(int index, const char* value);
+ void set_blobhashes(int index, const char* value, size_t size);
+ std::string* add_blobhashes();
+ void add_blobhashes(const std::string& value);
+ void add_blobhashes(std::string&& value);
+ void add_blobhashes(const char* value);
+ void add_blobhashes(const char* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
+ private:
+ const std::string& _internal_blobhashes(int index) const;
+ std::string* _internal_add_blobhashes();
public:
- // string deviceToken = 2;
- void clear_devicetoken();
- const std::string& devicetoken() const;
- void set_devicetoken(const std::string& value);
- void set_devicetoken(std::string&& value);
- void set_devicetoken(const char* value);
- void set_devicetoken(const char* value, size_t size);
- std::string* mutable_devicetoken();
- std::string* release_devicetoken();
- void set_allocated_devicetoken(std::string* devicetoken);
+ // string toDeviceID = 1;
+ void clear_todeviceid();
+ const std::string& todeviceid() const;
+ void set_todeviceid(const std::string& value);
+ void set_todeviceid(std::string&& value);
+ void set_todeviceid(const char* value);
+ void set_todeviceid(const char* value, size_t size);
+ std::string* mutable_todeviceid();
+ std::string* release_todeviceid();
+ void set_allocated_todeviceid(std::string* todeviceid);
private:
- const std::string& _internal_devicetoken() const;
- void _internal_set_devicetoken(const std::string& value);
- std::string* _internal_mutable_devicetoken();
+ const std::string& _internal_todeviceid() const;
+ void _internal_set_todeviceid(const std::string& value);
+ std::string* _internal_mutable_todeviceid();
public:
- // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
+ // string payload = 2;
+ void clear_payload();
+ const std::string& payload() const;
+ void set_payload(const std::string& value);
+ void set_payload(std::string&& value);
+ void set_payload(const char* value);
+ void set_payload(const char* value, size_t size);
+ std::string* mutable_payload();
+ std::string* release_payload();
+ void set_allocated_payload(std::string* payload);
+ private:
+ const std::string& _internal_payload() const;
+ void _internal_set_payload(const std::string& value);
+ std::string* _internal_mutable_payload();
+ public:
+
+ // @@protoc_insertion_point(class_scope:tunnelbroker.OutboundMessage)
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 devicetoken_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_tunnelbroker_2eproto;
};
// -------------------------------------------------------------------
-class CheckResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
+class InboundMessage PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.InboundMessage) */ {
public:
- inline CheckResponse() : CheckResponse(nullptr) {}
- virtual ~CheckResponse();
- explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline InboundMessage() : InboundMessage(nullptr) {}
+ virtual ~InboundMessage();
+ explicit constexpr InboundMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- CheckResponse(const CheckResponse& from);
- CheckResponse(CheckResponse&& from) noexcept
- : CheckResponse() {
+ InboundMessage(const InboundMessage& from);
+ InboundMessage(InboundMessage&& from) noexcept
+ : InboundMessage() {
*this = ::std::move(from);
}
- inline CheckResponse& operator=(const CheckResponse& from) {
+ inline InboundMessage& operator=(const InboundMessage& from) {
CopyFrom(from);
return *this;
}
- inline CheckResponse& operator=(CheckResponse&& from) noexcept {
+ inline InboundMessage& operator=(InboundMessage&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -1614,20 +1648,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const CheckResponse& default_instance() {
+ static const InboundMessage& default_instance() {
return *internal_default_instance();
}
- static inline const CheckResponse* internal_default_instance() {
- return reinterpret_cast<const CheckResponse*>(
- &_CheckResponse_default_instance_);
+ static inline const InboundMessage* internal_default_instance() {
+ return reinterpret_cast<const InboundMessage*>(
+ &_InboundMessage_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
- friend void swap(CheckResponse& a, CheckResponse& b) {
+ friend void swap(InboundMessage& a, InboundMessage& b) {
a.Swap(&b);
}
- inline void Swap(CheckResponse* other) {
+ inline void Swap(InboundMessage* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -1635,7 +1669,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(CheckResponse* other) {
+ void UnsafeArenaSwap(InboundMessage* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -1643,17 +1677,17 @@
// implements Message ----------------------------------------------
- inline CheckResponse* New() const final {
- return CreateMaybeMessage<CheckResponse>(nullptr);
+ inline InboundMessage* New() const final {
+ return CreateMaybeMessage<InboundMessage>(nullptr);
}
- CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<CheckResponse>(arena);
+ InboundMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<InboundMessage>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const CheckResponse& from);
- void MergeFrom(const CheckResponse& from);
+ void CopyFrom(const InboundMessage& from);
+ void MergeFrom(const InboundMessage& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -1667,13 +1701,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(CheckResponse* other);
+ void InternalSwap(InboundMessage* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "tunnelbroker.CheckResponse";
+ return "tunnelbroker.InboundMessage";
}
protected:
- explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1692,48 +1726,117 @@
// accessors -------------------------------------------------------
enum : int {
- kCheckResponseTypeFieldNumber = 1,
+ kBlobHashesFieldNumber = 4,
+ kFromDeviceIDFieldNumber = 1,
+ kFromConnectionIDFieldNumber = 2,
+ kPayloadFieldNumber = 3,
};
- // .tunnelbroker.CheckResponseType checkResponseType = 1;
- void clear_checkresponsetype();
- ::tunnelbroker::CheckResponseType checkresponsetype() const;
- void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
+ // repeated string blobHashes = 4;
+ int blobhashes_size() const;
private:
- ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
- void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
+ int _internal_blobhashes_size() const;
+ public:
+ void clear_blobhashes();
+ const std::string& blobhashes(int index) const;
+ std::string* mutable_blobhashes(int index);
+ void set_blobhashes(int index, const std::string& value);
+ void set_blobhashes(int index, std::string&& value);
+ void set_blobhashes(int index, const char* value);
+ void set_blobhashes(int index, const char* value, size_t size);
+ std::string* add_blobhashes();
+ void add_blobhashes(const std::string& value);
+ void add_blobhashes(std::string&& value);
+ void add_blobhashes(const char* value);
+ void add_blobhashes(const char* value, size_t size);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& blobhashes() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_blobhashes();
+ private:
+ const std::string& _internal_blobhashes(int index) const;
+ std::string* _internal_add_blobhashes();
public:
- // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
+ // string fromDeviceID = 1;
+ void clear_fromdeviceid();
+ const std::string& fromdeviceid() const;
+ void set_fromdeviceid(const std::string& value);
+ void set_fromdeviceid(std::string&& value);
+ void set_fromdeviceid(const char* value);
+ void set_fromdeviceid(const char* value, size_t size);
+ std::string* mutable_fromdeviceid();
+ std::string* release_fromdeviceid();
+ void set_allocated_fromdeviceid(std::string* fromdeviceid);
+ private:
+ const std::string& _internal_fromdeviceid() const;
+ void _internal_set_fromdeviceid(const std::string& value);
+ std::string* _internal_mutable_fromdeviceid();
+ public:
+
+ // string fromConnectionID = 2;
+ void clear_fromconnectionid();
+ const std::string& fromconnectionid() const;
+ void set_fromconnectionid(const std::string& value);
+ void set_fromconnectionid(std::string&& value);
+ void set_fromconnectionid(const char* value);
+ void set_fromconnectionid(const char* value, size_t size);
+ std::string* mutable_fromconnectionid();
+ std::string* release_fromconnectionid();
+ void set_allocated_fromconnectionid(std::string* fromconnectionid);
+ private:
+ const std::string& _internal_fromconnectionid() const;
+ void _internal_set_fromconnectionid(const std::string& value);
+ std::string* _internal_mutable_fromconnectionid();
+ public:
+
+ // string payload = 3;
+ void clear_payload();
+ const std::string& payload() const;
+ void set_payload(const std::string& value);
+ void set_payload(std::string&& value);
+ void set_payload(const char* value);
+ void set_payload(const char* value, size_t size);
+ std::string* mutable_payload();
+ std::string* release_payload();
+ void set_allocated_payload(std::string* payload);
+ private:
+ const std::string& _internal_payload() const;
+ void _internal_set_payload(const std::string& value);
+ std::string* _internal_mutable_payload();
+ public:
+
+ // @@protoc_insertion_point(class_scope:tunnelbroker.InboundMessage)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
- int checkresponsetype_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> blobhashes_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromconnectionid_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_tunnelbroker_2eproto;
};
// -------------------------------------------------------------------
-class NewPrimaryRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
+class CheckRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ {
public:
- inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
- virtual ~NewPrimaryRequest();
- explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline CheckRequest() : CheckRequest(nullptr) {}
+ virtual ~CheckRequest();
+ explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- NewPrimaryRequest(const NewPrimaryRequest& from);
- NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
- : NewPrimaryRequest() {
+ CheckRequest(const CheckRequest& from);
+ CheckRequest(CheckRequest&& from) noexcept
+ : CheckRequest() {
*this = ::std::move(from);
}
- inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
+ inline CheckRequest& operator=(const CheckRequest& from) {
CopyFrom(from);
return *this;
}
- inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
+ inline CheckRequest& operator=(CheckRequest&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -1751,20 +1854,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const NewPrimaryRequest& default_instance() {
+ static const CheckRequest& default_instance() {
return *internal_default_instance();
}
- static inline const NewPrimaryRequest* internal_default_instance() {
- return reinterpret_cast<const NewPrimaryRequest*>(
- &_NewPrimaryRequest_default_instance_);
+ static inline const CheckRequest* internal_default_instance() {
+ return reinterpret_cast<const CheckRequest*>(
+ &_CheckRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
- friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
+ friend void swap(CheckRequest& a, CheckRequest& b) {
a.Swap(&b);
}
- inline void Swap(NewPrimaryRequest* other) {
+ inline void Swap(CheckRequest* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -1772,7 +1875,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(NewPrimaryRequest* other) {
+ void UnsafeArenaSwap(CheckRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -1780,17 +1883,17 @@
// implements Message ----------------------------------------------
- inline NewPrimaryRequest* New() const final {
- return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
+ inline CheckRequest* New() const final {
+ return CreateMaybeMessage<CheckRequest>(nullptr);
}
- NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<NewPrimaryRequest>(arena);
+ CheckRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<CheckRequest>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const NewPrimaryRequest& from);
- void MergeFrom(const NewPrimaryRequest& from);
+ void CopyFrom(const CheckRequest& from);
+ void MergeFrom(const CheckRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -1804,13 +1907,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(NewPrimaryRequest* other);
+ void InternalSwap(CheckRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "tunnelbroker.NewPrimaryRequest";
+ return "tunnelbroker.CheckRequest";
}
protected:
- explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1864,7 +1967,7 @@
std::string* _internal_mutable_devicetoken();
public:
- // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
+ // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest)
private:
class _Internal;
@@ -1878,24 +1981,24 @@
};
// -------------------------------------------------------------------
-class NewPrimaryResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
+class CheckResponse PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ {
public:
- inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
- virtual ~NewPrimaryResponse();
- explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline CheckResponse() : CheckResponse(nullptr) {}
+ virtual ~CheckResponse();
+ explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- NewPrimaryResponse(const NewPrimaryResponse& from);
- NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
- : NewPrimaryResponse() {
+ CheckResponse(const CheckResponse& from);
+ CheckResponse(CheckResponse&& from) noexcept
+ : CheckResponse() {
*this = ::std::move(from);
}
- inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
+ inline CheckResponse& operator=(const CheckResponse& from) {
CopyFrom(from);
return *this;
}
- inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
+ inline CheckResponse& operator=(CheckResponse&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -1913,20 +2016,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const NewPrimaryResponse& default_instance() {
+ static const CheckResponse& default_instance() {
return *internal_default_instance();
}
- static inline const NewPrimaryResponse* internal_default_instance() {
- return reinterpret_cast<const NewPrimaryResponse*>(
- &_NewPrimaryResponse_default_instance_);
+ static inline const CheckResponse* internal_default_instance() {
+ return reinterpret_cast<const CheckResponse*>(
+ &_CheckResponse_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
- friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
+ friend void swap(CheckResponse& a, CheckResponse& b) {
a.Swap(&b);
}
- inline void Swap(NewPrimaryResponse* other) {
+ inline void Swap(CheckResponse* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -1934,7 +2037,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(NewPrimaryResponse* other) {
+ void UnsafeArenaSwap(CheckResponse* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -1942,17 +2045,17 @@
// implements Message ----------------------------------------------
- inline NewPrimaryResponse* New() const final {
- return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
+ inline CheckResponse* New() const final {
+ return CreateMaybeMessage<CheckResponse>(nullptr);
}
- NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<NewPrimaryResponse>(arena);
+ CheckResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<CheckResponse>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const NewPrimaryResponse& from);
- void MergeFrom(const NewPrimaryResponse& from);
+ void CopyFrom(const CheckResponse& from);
+ void MergeFrom(const CheckResponse& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -1966,13 +2069,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(NewPrimaryResponse* other);
+ void InternalSwap(CheckResponse* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "tunnelbroker.NewPrimaryResponse";
+ return "tunnelbroker.CheckResponse";
}
protected:
- explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -1991,48 +2094,48 @@
// accessors -------------------------------------------------------
enum : int {
- kSuccessFieldNumber = 1,
+ kCheckResponseTypeFieldNumber = 1,
};
- // bool success = 1;
- void clear_success();
- bool success() const;
- void set_success(bool value);
+ // .tunnelbroker.CheckResponseType checkResponseType = 1;
+ void clear_checkresponsetype();
+ ::tunnelbroker::CheckResponseType checkresponsetype() const;
+ void set_checkresponsetype(::tunnelbroker::CheckResponseType value);
private:
- bool _internal_success() const;
- void _internal_set_success(bool value);
+ ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const;
+ void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value);
public:
- // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
+ // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
- bool success_;
+ int checkresponsetype_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_tunnelbroker_2eproto;
};
// -------------------------------------------------------------------
-class PongRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
+class NewPrimaryRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ {
public:
- inline PongRequest() : PongRequest(nullptr) {}
- virtual ~PongRequest();
- explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+ inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {}
+ virtual ~NewPrimaryRequest();
+ explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
- PongRequest(const PongRequest& from);
- PongRequest(PongRequest&& from) noexcept
- : PongRequest() {
+ NewPrimaryRequest(const NewPrimaryRequest& from);
+ NewPrimaryRequest(NewPrimaryRequest&& from) noexcept
+ : NewPrimaryRequest() {
*this = ::std::move(from);
}
- inline PongRequest& operator=(const PongRequest& from) {
+ inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) {
CopyFrom(from);
return *this;
}
- inline PongRequest& operator=(PongRequest&& from) noexcept {
+ inline NewPrimaryRequest& operator=(NewPrimaryRequest&& from) noexcept {
if (GetArena() == from.GetArena()) {
if (this != &from) InternalSwap(&from);
} else {
@@ -2050,20 +2153,20 @@
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
- static const PongRequest& default_instance() {
+ static const NewPrimaryRequest& default_instance() {
return *internal_default_instance();
}
- static inline const PongRequest* internal_default_instance() {
- return reinterpret_cast<const PongRequest*>(
- &_PongRequest_default_instance_);
+ static inline const NewPrimaryRequest* internal_default_instance() {
+ return reinterpret_cast<const NewPrimaryRequest*>(
+ &_NewPrimaryRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
- friend void swap(PongRequest& a, PongRequest& b) {
+ friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) {
a.Swap(&b);
}
- inline void Swap(PongRequest* other) {
+ inline void Swap(NewPrimaryRequest* other) {
if (other == this) return;
if (GetArena() == other->GetArena()) {
InternalSwap(other);
@@ -2071,7 +2174,7 @@
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
}
}
- void UnsafeArenaSwap(PongRequest* other) {
+ void UnsafeArenaSwap(NewPrimaryRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetArena() == other->GetArena());
InternalSwap(other);
@@ -2079,17 +2182,17 @@
// implements Message ----------------------------------------------
- inline PongRequest* New() const final {
- return CreateMaybeMessage<PongRequest>(nullptr);
+ inline NewPrimaryRequest* New() const final {
+ return CreateMaybeMessage<NewPrimaryRequest>(nullptr);
}
- PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PongRequest>(arena);
+ NewPrimaryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<NewPrimaryRequest>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PongRequest& from);
- void MergeFrom(const PongRequest& from);
+ void CopyFrom(const NewPrimaryRequest& from);
+ void MergeFrom(const NewPrimaryRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
@@ -2103,13 +2206,13 @@
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
- void InternalSwap(PongRequest* other);
+ void InternalSwap(NewPrimaryRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "tunnelbroker.PongRequest";
+ return "tunnelbroker.NewPrimaryRequest";
}
protected:
- explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
@@ -2163,7 +2266,7 @@
std::string* _internal_mutable_devicetoken();
public:
- // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
+ // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest)
private:
class _Internal;
@@ -2175,726 +2278,1490 @@
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_tunnelbroker_2eproto;
};
-// ===================================================================
+// -------------------------------------------------------------------
+class NewPrimaryResponse PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ {
+ public:
+ inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {}
+ virtual ~NewPrimaryResponse();
+ explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-// ===================================================================
+ NewPrimaryResponse(const NewPrimaryResponse& from);
+ NewPrimaryResponse(NewPrimaryResponse&& from) noexcept
+ : NewPrimaryResponse() {
+ *this = ::std::move(from);
+ }
-#ifdef __GNUC__
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif // __GNUC__
-// SessionSignatureRequest
+ inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept {
+ if (GetArena() == from.GetArena()) {
+ if (this != &from) InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
-// string deviceID = 1;
-inline void SessionSignatureRequest::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& SessionSignatureRequest::deviceid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
- return _internal_deviceid();
-}
-inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline std::string* SessionSignatureRequest::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline void SessionSignatureRequest::set_deviceid(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline void SessionSignatureRequest::set_deviceid(const char* value,
- size_t size) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
-}
-inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* SessionSignatureRequest::release_deviceid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
- if (deviceid != nullptr) {
-
- } else {
-
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
}
- deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
-}
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return GetMetadataStatic().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return GetMetadataStatic().reflection;
+ }
+ static const NewPrimaryResponse& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const NewPrimaryResponse* internal_default_instance() {
+ return reinterpret_cast<const NewPrimaryResponse*>(
+ &_NewPrimaryResponse_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 12;
-// -------------------------------------------------------------------
+ friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(NewPrimaryResponse* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(NewPrimaryResponse* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
-// SessionSignatureResponse
+ // implements Message ----------------------------------------------
-// string toSign = 1;
-inline void SessionSignatureResponse::clear_tosign() {
- tosign_.ClearToEmpty();
-}
-inline const std::string& SessionSignatureResponse::tosign() const {
+ inline NewPrimaryResponse* New() const final {
+ return CreateMaybeMessage<NewPrimaryResponse>(nullptr);
+ }
+
+ NewPrimaryResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<NewPrimaryResponse>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const NewPrimaryResponse& from);
+ void MergeFrom(const NewPrimaryResponse& 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(NewPrimaryResponse* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "tunnelbroker.NewPrimaryResponse";
+ }
+ protected:
+ explicit NewPrimaryResponse(::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_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kSuccessFieldNumber = 1,
+ };
+ // bool success = 1;
+ void clear_success();
+ bool success() const;
+ void set_success(bool value);
+ private:
+ bool _internal_success() const;
+ void _internal_set_success(bool value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ bool success_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_tunnelbroker_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PongRequest PROTOBUF_FINAL :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ {
+ public:
+ inline PongRequest() : PongRequest(nullptr) {}
+ virtual ~PongRequest();
+ explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ PongRequest(const PongRequest& from);
+ PongRequest(PongRequest&& from) noexcept
+ : PongRequest() {
+ *this = ::std::move(from);
+ }
+
+ inline PongRequest& operator=(const PongRequest& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline PongRequest& operator=(PongRequest&& 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 PongRequest& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const PongRequest* internal_default_instance() {
+ return reinterpret_cast<const PongRequest*>(
+ &_PongRequest_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 13;
+
+ friend void swap(PongRequest& a, PongRequest& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(PongRequest* other) {
+ if (other == this) return;
+ if (GetArena() == other->GetArena()) {
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(PongRequest* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetArena() == other->GetArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ inline PongRequest* New() const final {
+ return CreateMaybeMessage<PongRequest>(nullptr);
+ }
+
+ PongRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+ return CreateMaybeMessage<PongRequest>(arena);
+ }
+ void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+ void CopyFrom(const PongRequest& from);
+ void MergeFrom(const PongRequest& 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(PongRequest* other);
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "tunnelbroker.PongRequest";
+ }
+ protected:
+ explicit PongRequest(::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_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages);
+ }
+
+ public:
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kUserIdFieldNumber = 1,
+ kDeviceTokenFieldNumber = 2,
+ };
+ // 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 deviceToken = 2;
+ void clear_devicetoken();
+ const std::string& devicetoken() const;
+ void set_devicetoken(const std::string& value);
+ void set_devicetoken(std::string&& value);
+ void set_devicetoken(const char* value);
+ void set_devicetoken(const char* value, size_t size);
+ std::string* mutable_devicetoken();
+ std::string* release_devicetoken();
+ void set_allocated_devicetoken(std::string* devicetoken);
+ private:
+ const std::string& _internal_devicetoken() const;
+ void _internal_set_devicetoken(const std::string& value);
+ std::string* _internal_mutable_devicetoken();
+ public:
+
+ // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest)
+ 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 devicetoken_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_tunnelbroker_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// SessionSignatureRequest
+
+// string deviceID = 1;
+inline void SessionSignatureRequest::clear_deviceid() {
+ deviceid_.ClearToEmpty();
+}
+inline const std::string& SessionSignatureRequest::deviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID)
+ return _internal_deviceid();
+}
+inline void SessionSignatureRequest::set_deviceid(const std::string& value) {
+ _internal_set_deviceid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline std::string* SessionSignatureRequest::mutable_deviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID)
+ return _internal_mutable_deviceid();
+}
+inline const std::string& SessionSignatureRequest::_internal_deviceid() const {
+ return deviceid_.Get();
+}
+inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) {
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SessionSignatureRequest::set_deviceid(std::string&& value) {
+
+ deviceid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline void SessionSignatureRequest::set_deviceid(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline void SessionSignatureRequest::set_deviceid(const char* value,
+ size_t size) {
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() {
+
+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SessionSignatureRequest::release_deviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID)
+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) {
+ if (deviceid != nullptr) {
+
+ } else {
+
+ }
+ deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID)
+}
+
+// -------------------------------------------------------------------
+
+// SessionSignatureResponse
+
+// string toSign = 1;
+inline void SessionSignatureResponse::clear_tosign() {
+ tosign_.ClearToEmpty();
+}
+inline const std::string& SessionSignatureResponse::tosign() const {
// @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureResponse.toSign)
return _internal_tosign();
}
-inline void SessionSignatureResponse::set_tosign(const std::string& value) {
- _internal_set_tosign(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
+inline void SessionSignatureResponse::set_tosign(const std::string& value) {
+ _internal_set_tosign(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline std::string* SessionSignatureResponse::mutable_tosign() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
+ return _internal_mutable_tosign();
+}
+inline const std::string& SessionSignatureResponse::_internal_tosign() const {
+ return tosign_.Get();
+}
+inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
+
+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SessionSignatureResponse::set_tosign(std::string&& value) {
+
+ tosign_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline void SessionSignatureResponse::set_tosign(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline void SessionSignatureResponse::set_tosign(const char* value,
+ size_t size) {
+
+ tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
+}
+inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
+
+ return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SessionSignatureResponse::release_tosign() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
+ return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
+ if (tosign != nullptr) {
+
+ } else {
+
+ }
+ tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
+}
+
+// -------------------------------------------------------------------
+
+// NewSessionRequest
+
+// string deviceID = 1;
+inline void NewSessionRequest::clear_deviceid() {
+ deviceid_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::deviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
+ return _internal_deviceid();
+}
+inline void NewSessionRequest::set_deviceid(const std::string& value) {
+ _internal_set_deviceid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline std::string* NewSessionRequest::mutable_deviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
+ return _internal_mutable_deviceid();
+}
+inline const std::string& NewSessionRequest::_internal_deviceid() const {
+ return deviceid_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_deviceid(std::string&& value) {
+
+ deviceid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline void NewSessionRequest::set_deviceid(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline void NewSessionRequest::set_deviceid(const char* value,
+ size_t size) {
+
+ deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
+}
+inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
+
+ return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_deviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
+ return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
+ if (deviceid != nullptr) {
+
+ } else {
+
+ }
+ deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
+}
+
+// string publicKey = 2;
+inline void NewSessionRequest::clear_publickey() {
+ publickey_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::publickey() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
+ return _internal_publickey();
+}
+inline void NewSessionRequest::set_publickey(const std::string& value) {
+ _internal_set_publickey(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline std::string* NewSessionRequest::mutable_publickey() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
+ return _internal_mutable_publickey();
+}
+inline const std::string& NewSessionRequest::_internal_publickey() const {
+ return publickey_.Get();
+}
+inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
+
+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_publickey(std::string&& value) {
+
+ publickey_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline void NewSessionRequest::set_publickey(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline void NewSessionRequest::set_publickey(const char* value,
+ size_t size) {
+
+ publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
+}
+inline std::string* NewSessionRequest::_internal_mutable_publickey() {
+
+ return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_publickey() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
+ return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
+ if (publickey != nullptr) {
+
+ } else {
+
+ }
+ publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
+}
+
+// string signature = 3;
+inline void NewSessionRequest::clear_signature() {
+ signature_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::signature() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
+ return _internal_signature();
+}
+inline void NewSessionRequest::set_signature(const std::string& value) {
+ _internal_set_signature(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
+}
+inline std::string* NewSessionRequest::mutable_signature() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
+ return _internal_mutable_signature();
+}
+inline const std::string& NewSessionRequest::_internal_signature() const {
+ return signature_.Get();
+}
+inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
+
+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_signature(std::string&& value) {
+
+ signature_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
+}
+inline void NewSessionRequest::set_signature(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
+}
+inline void NewSessionRequest::set_signature(const char* value,
+ size_t size) {
+
+ signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
+}
+inline std::string* NewSessionRequest::_internal_mutable_signature() {
+
+ return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_signature() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
+ return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
+ if (signature != nullptr) {
+
+ } else {
+
+ }
+ signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
+}
+
+// string notifyToken = 4;
+inline bool NewSessionRequest::_internal_has_notifytoken() const {
+ bool value = (_has_bits_[0] & 0x00000001u) != 0;
+ return value;
+}
+inline bool NewSessionRequest::has_notifytoken() const {
+ return _internal_has_notifytoken();
+}
+inline void NewSessionRequest::clear_notifytoken() {
+ notifytoken_.ClearToEmpty();
+ _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& NewSessionRequest::notifytoken() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
+ return _internal_notifytoken();
+}
+inline void NewSessionRequest::set_notifytoken(const std::string& value) {
+ _internal_set_notifytoken(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline std::string* NewSessionRequest::mutable_notifytoken() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
+ return _internal_mutable_notifytoken();
+}
+inline const std::string& NewSessionRequest::_internal_notifytoken() const {
+ return notifytoken_.Get();
+}
+inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
+ _has_bits_[0] |= 0x00000001u;
+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_notifytoken(std::string&& value) {
+ _has_bits_[0] |= 0x00000001u;
+ notifytoken_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline void NewSessionRequest::set_notifytoken(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ _has_bits_[0] |= 0x00000001u;
+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline void NewSessionRequest::set_notifytoken(const char* value,
+ size_t size) {
+ _has_bits_[0] |= 0x00000001u;
+ notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
+}
+inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
+ _has_bits_[0] |= 0x00000001u;
+ return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_notifytoken() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
+ if (!_internal_has_notifytoken()) {
+ return nullptr;
+ }
+ _has_bits_[0] &= ~0x00000001u;
+ return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
+ if (notifytoken != nullptr) {
+ _has_bits_[0] |= 0x00000001u;
+ } else {
+ _has_bits_[0] &= ~0x00000001u;
+ }
+ notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
+}
+
+// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
+inline void NewSessionRequest::clear_devicetype() {
+ devicetype_ = 0;
+}
+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
+ return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
+}
+inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
+ return _internal_devicetype();
+}
+inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
+
+ devicetype_ = value;
+}
+inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
+ _internal_set_devicetype(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
+}
+
+// string deviceAppVersion = 6;
+inline void NewSessionRequest::clear_deviceappversion() {
+ deviceappversion_.ClearToEmpty();
+}
+inline const std::string& NewSessionRequest::deviceappversion() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ return _internal_deviceappversion();
+}
+inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
+ _internal_set_deviceappversion(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline std::string* NewSessionRequest::mutable_deviceappversion() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ return _internal_mutable_deviceappversion();
+}
+inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
+ return deviceappversion_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
+
+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
+
+ deviceappversion_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline void NewSessionRequest::set_deviceappversion(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline void NewSessionRequest::set_deviceappversion(const char* value,
+ size_t size) {
+
+ deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
+}
+inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
+
+ return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* NewSessionRequest::release_deviceappversion() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
+ if (deviceappversion != nullptr) {
+
+ } else {
+
+ }
+ deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
}
-inline std::string* SessionSignatureResponse::mutable_tosign() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign)
- return _internal_mutable_tosign();
+
+// string deviceOS = 7;
+inline void NewSessionRequest::clear_deviceos() {
+ deviceos_.ClearToEmpty();
}
-inline const std::string& SessionSignatureResponse::_internal_tosign() const {
- return tosign_.Get();
+inline const std::string& NewSessionRequest::deviceos() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
+ return _internal_deviceos();
}
-inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) {
+inline void NewSessionRequest::set_deviceos(const std::string& value) {
+ _internal_set_deviceos(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
+}
+inline std::string* NewSessionRequest::mutable_deviceos() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
+ return _internal_mutable_deviceos();
+}
+inline const std::string& NewSessionRequest::_internal_deviceos() const {
+ return deviceos_.Get();
+}
+inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {
- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void SessionSignatureResponse::set_tosign(std::string&& value) {
+inline void NewSessionRequest::set_deviceos(std::string&& value) {
- tosign_.Set(
+ deviceos_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
}
-inline void SessionSignatureResponse::set_tosign(const char* value) {
+inline void NewSessionRequest::set_deviceos(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign)
+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
}
-inline void SessionSignatureResponse::set_tosign(const char* value,
+inline void NewSessionRequest::set_deviceos(const char* value,
size_t size) {
- tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
}
-inline std::string* SessionSignatureResponse::_internal_mutable_tosign() {
+inline std::string* NewSessionRequest::_internal_mutable_deviceos() {
- return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* SessionSignatureResponse::release_tosign() {
- // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign)
- return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* NewSessionRequest::release_deviceos() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
+ return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) {
- if (tosign != nullptr) {
+inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
+ if (deviceos != nullptr) {
} else {
}
- tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign,
+ deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
}
// -------------------------------------------------------------------
-// NewSessionRequest
+// NewSessionResponse
-// string deviceID = 1;
-inline void NewSessionRequest::clear_deviceid() {
- deviceid_.ClearToEmpty();
+// string sessionID = 1;
+inline void NewSessionResponse::clear_sessionid() {
+ sessionid_.ClearToEmpty();
}
-inline const std::string& NewSessionRequest::deviceid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID)
- return _internal_deviceid();
+inline const std::string& NewSessionResponse::sessionid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
+ return _internal_sessionid();
}
-inline void NewSessionRequest::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID)
+inline void NewSessionResponse::set_sessionid(const std::string& value) {
+ _internal_set_sessionid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
}
-inline std::string* NewSessionRequest::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID)
- return _internal_mutable_deviceid();
+inline std::string* NewSessionResponse::mutable_sessionid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
+ return _internal_mutable_sessionid();
}
-inline const std::string& NewSessionRequest::_internal_deviceid() const {
- return deviceid_.Get();
+inline const std::string& NewSessionResponse::_internal_sessionid() const {
+ return sessionid_.Get();
}
-inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) {
+inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionRequest::set_deviceid(std::string&& value) {
+inline void NewSessionResponse::set_sessionid(std::string&& value) {
- deviceid_.Set(
+ sessionid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
}
-inline void NewSessionRequest::set_deviceid(const char* value) {
+inline void NewSessionResponse::set_sessionid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID)
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
}
-inline void NewSessionRequest::set_deviceid(const char* value,
+inline void NewSessionResponse::set_sessionid(const char* value,
size_t size) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
}
-inline std::string* NewSessionRequest::_internal_mutable_deviceid() {
+inline std::string* NewSessionResponse::_internal_mutable_sessionid() {
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionRequest::release_deviceid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* NewSessionResponse::release_sessionid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) {
- if (deviceid != nullptr) {
+inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
+ if (sessionid != nullptr) {
} else {
}
- deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid,
+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
}
-// bytes publicKey = 2;
-inline void NewSessionRequest::clear_publickey() {
- publickey_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// SendRequest
+
+// string sessionID = 1;
+inline void SendRequest::clear_sessionid() {
+ sessionid_.ClearToEmpty();
}
-inline const std::string& NewSessionRequest::publickey() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey)
- return _internal_publickey();
+inline const std::string& SendRequest::sessionid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
+ return _internal_sessionid();
}
-inline void NewSessionRequest::set_publickey(const std::string& value) {
- _internal_set_publickey(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey)
+inline void SendRequest::set_sessionid(const std::string& value) {
+ _internal_set_sessionid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
}
-inline std::string* NewSessionRequest::mutable_publickey() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey)
- return _internal_mutable_publickey();
+inline std::string* SendRequest::mutable_sessionid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
+ return _internal_mutable_sessionid();
}
-inline const std::string& NewSessionRequest::_internal_publickey() const {
- return publickey_.Get();
+inline const std::string& SendRequest::_internal_sessionid() const {
+ return sessionid_.Get();
}
-inline void NewSessionRequest::_internal_set_publickey(const std::string& value) {
+inline void SendRequest::_internal_set_sessionid(const std::string& value) {
- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionRequest::set_publickey(std::string&& value) {
+inline void SendRequest::set_sessionid(std::string&& value) {
- publickey_.Set(
+ sessionid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
}
-inline void NewSessionRequest::set_publickey(const char* value) {
+inline void SendRequest::set_sessionid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey)
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
+}
+inline void SendRequest::set_sessionid(const char* value,
+ size_t size) {
+
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ reinterpret_cast<const char*>(value), size), GetArena());
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
+}
+inline std::string* SendRequest::_internal_mutable_sessionid() {
+
+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+}
+inline std::string* SendRequest::release_sessionid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
+ if (sessionid != nullptr) {
+
+ } else {
+
+ }
+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+ GetArena());
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
+}
+
+// string toDeviceID = 2;
+inline void SendRequest::clear_todeviceid() {
+ todeviceid_.ClearToEmpty();
+}
+inline const std::string& SendRequest::todeviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
+ return _internal_todeviceid();
+}
+inline void SendRequest::set_todeviceid(const std::string& value) {
+ _internal_set_todeviceid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
+}
+inline std::string* SendRequest::mutable_todeviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
+ return _internal_mutable_todeviceid();
+}
+inline const std::string& SendRequest::_internal_todeviceid() const {
+ return todeviceid_.Get();
+}
+inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
+
+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+}
+inline void SendRequest::set_todeviceid(std::string&& value) {
+
+ todeviceid_.Set(
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
+}
+inline void SendRequest::set_todeviceid(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+
+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
}
-inline void NewSessionRequest::set_publickey(const void* value,
+inline void SendRequest::set_todeviceid(const char* value,
size_t size) {
- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
}
-inline std::string* NewSessionRequest::_internal_mutable_publickey() {
+inline std::string* SendRequest::_internal_mutable_todeviceid() {
- return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionRequest::release_publickey() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey)
- return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::release_todeviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
+ return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) {
- if (publickey != nullptr) {
+inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
+ if (todeviceid != nullptr) {
} else {
}
- publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey,
+ todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
}
-// string signature = 3;
-inline void NewSessionRequest::clear_signature() {
- signature_.ClearToEmpty();
+// bytes payload = 3;
+inline void SendRequest::clear_payload() {
+ payload_.ClearToEmpty();
}
-inline const std::string& NewSessionRequest::signature() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature)
- return _internal_signature();
+inline const std::string& SendRequest::payload() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
+ return _internal_payload();
}
-inline void NewSessionRequest::set_signature(const std::string& value) {
- _internal_set_signature(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature)
+inline void SendRequest::set_payload(const std::string& value) {
+ _internal_set_payload(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
}
-inline std::string* NewSessionRequest::mutable_signature() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature)
- return _internal_mutable_signature();
+inline std::string* SendRequest::mutable_payload() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
+ return _internal_mutable_payload();
}
-inline const std::string& NewSessionRequest::_internal_signature() const {
- return signature_.Get();
+inline const std::string& SendRequest::_internal_payload() const {
+ return payload_.Get();
}
-inline void NewSessionRequest::_internal_set_signature(const std::string& value) {
+inline void SendRequest::_internal_set_payload(const std::string& value) {
- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionRequest::set_signature(std::string&& value) {
+inline void SendRequest::set_payload(std::string&& value) {
- signature_.Set(
+ payload_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
}
-inline void NewSessionRequest::set_signature(const char* value) {
+inline void SendRequest::set_payload(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature)
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
}
-inline void NewSessionRequest::set_signature(const char* value,
+inline void SendRequest::set_payload(const void* value,
size_t size) {
- signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
}
-inline std::string* NewSessionRequest::_internal_mutable_signature() {
+inline std::string* SendRequest::_internal_mutable_payload() {
- return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionRequest::release_signature() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature)
- return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::release_payload() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
+ return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionRequest::set_allocated_signature(std::string* signature) {
- if (signature != nullptr) {
+inline void SendRequest::set_allocated_payload(std::string* payload) {
+ if (payload != nullptr) {
} else {
}
- signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+ payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
}
-// string notifyToken = 4;
-inline bool NewSessionRequest::_internal_has_notifytoken() const {
- bool value = (_has_bits_[0] & 0x00000001u) != 0;
- return value;
+// repeated string blobHashes = 4;
+inline int SendRequest::_internal_blobhashes_size() const {
+ return blobhashes_.size();
}
-inline bool NewSessionRequest::has_notifytoken() const {
- return _internal_has_notifytoken();
+inline int SendRequest::blobhashes_size() const {
+ return _internal_blobhashes_size();
}
-inline void NewSessionRequest::clear_notifytoken() {
- notifytoken_.ClearToEmpty();
- _has_bits_[0] &= ~0x00000001u;
+inline void SendRequest::clear_blobhashes() {
+ blobhashes_.Clear();
}
-inline const std::string& NewSessionRequest::notifytoken() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken)
- return _internal_notifytoken();
+inline std::string* SendRequest::add_blobhashes() {
+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
+ return _internal_add_blobhashes();
}
-inline void NewSessionRequest::set_notifytoken(const std::string& value) {
- _internal_set_notifytoken(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken)
+inline const std::string& SendRequest::_internal_blobhashes(int index) const {
+ return blobhashes_.Get(index);
}
-inline std::string* NewSessionRequest::mutable_notifytoken() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken)
- return _internal_mutable_notifytoken();
+inline const std::string& SendRequest::blobhashes(int index) const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
+ return _internal_blobhashes(index);
}
-inline const std::string& NewSessionRequest::_internal_notifytoken() const {
- return notifytoken_.Get();
+inline std::string* SendRequest::mutable_blobhashes(int index) {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
+ return blobhashes_.Mutable(index);
}
-inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) {
- _has_bits_[0] |= 0x00000001u;
- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline void SendRequest::set_blobhashes(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+ blobhashes_.Mutable(index)->assign(value);
}
-inline void NewSessionRequest::set_notifytoken(std::string&& value) {
- _has_bits_[0] |= 0x00000001u;
- notifytoken_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken)
+inline void SendRequest::set_blobhashes(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+ blobhashes_.Mutable(index)->assign(std::move(value));
}
-inline void NewSessionRequest::set_notifytoken(const char* value) {
+inline void SendRequest::set_blobhashes(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
- _has_bits_[0] |= 0x00000001u;
- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken)
-}
-inline void NewSessionRequest::set_notifytoken(const char* value,
- size_t size) {
- _has_bits_[0] |= 0x00000001u;
- notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken)
+ blobhashes_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
}
-inline std::string* NewSessionRequest::_internal_mutable_notifytoken() {
- _has_bits_[0] |= 0x00000001u;
- return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
+ blobhashes_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
}
-inline std::string* NewSessionRequest::release_notifytoken() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken)
- if (!_internal_has_notifytoken()) {
- return nullptr;
- }
- _has_bits_[0] &= ~0x00000001u;
- return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* SendRequest::_internal_add_blobhashes() {
+ return blobhashes_.Add();
}
-inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) {
- if (notifytoken != nullptr) {
- _has_bits_[0] |= 0x00000001u;
- } else {
- _has_bits_[0] &= ~0x00000001u;
- }
- notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken)
+inline void SendRequest::add_blobhashes(const std::string& value) {
+ blobhashes_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
}
-
-// .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5;
-inline void NewSessionRequest::clear_devicetype() {
- devicetype_ = 0;
+inline void SendRequest::add_blobhashes(std::string&& value) {
+ blobhashes_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
}
-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const {
- return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_);
+inline void SendRequest::add_blobhashes(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ blobhashes_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
}
-inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType)
- return _internal_devicetype();
+inline void SendRequest::add_blobhashes(const char* value, size_t size) {
+ blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
}
-inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
-
- devicetype_ = value;
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SendRequest::blobhashes() const {
+ // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
+ return blobhashes_;
}
-inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) {
- _internal_set_devicetype(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType)
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SendRequest::mutable_blobhashes() {
+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
+ return &blobhashes_;
}
-// string deviceAppVersion = 6;
-inline void NewSessionRequest::clear_deviceappversion() {
- deviceappversion_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// GetRequest
+
+// string sessionID = 1;
+inline void GetRequest::clear_sessionid() {
+ sessionid_.ClearToEmpty();
}
-inline const std::string& NewSessionRequest::deviceappversion() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion)
- return _internal_deviceappversion();
+inline const std::string& GetRequest::sessionid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
+ return _internal_sessionid();
}
-inline void NewSessionRequest::set_deviceappversion(const std::string& value) {
- _internal_set_deviceappversion(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion)
+inline void GetRequest::set_sessionid(const std::string& value) {
+ _internal_set_sessionid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
}
-inline std::string* NewSessionRequest::mutable_deviceappversion() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion)
- return _internal_mutable_deviceappversion();
+inline std::string* GetRequest::mutable_sessionid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
+ return _internal_mutable_sessionid();
}
-inline const std::string& NewSessionRequest::_internal_deviceappversion() const {
- return deviceappversion_.Get();
+inline const std::string& GetRequest::_internal_sessionid() const {
+ return sessionid_.Get();
}
-inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) {
+inline void GetRequest::_internal_set_sessionid(const std::string& value) {
- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionRequest::set_deviceappversion(std::string&& value) {
+inline void GetRequest::set_sessionid(std::string&& value) {
- deviceappversion_.Set(
+ sessionid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
}
-inline void NewSessionRequest::set_deviceappversion(const char* value) {
+inline void GetRequest::set_sessionid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
}
-inline void NewSessionRequest::set_deviceappversion(const char* value,
+inline void GetRequest::set_sessionid(const char* value,
size_t size) {
- deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
}
-inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() {
+inline std::string* GetRequest::_internal_mutable_sessionid() {
- return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionRequest::release_deviceappversion() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion)
- return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetRequest::release_sessionid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
+ return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) {
- if (deviceappversion != nullptr) {
+inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
+ if (sessionid != nullptr) {
} else {
}
- deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion,
+ sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
}
-// string deviceOS = 7;
-inline void NewSessionRequest::clear_deviceos() {
- deviceos_.ClearToEmpty();
+// -------------------------------------------------------------------
+
+// GetResponse
+
+// string fromDeviceID = 1;
+inline void GetResponse::clear_fromdeviceid() {
+ fromdeviceid_.ClearToEmpty();
}
-inline const std::string& NewSessionRequest::deviceos() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS)
- return _internal_deviceos();
+inline const std::string& GetResponse::fromdeviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
+ return _internal_fromdeviceid();
}
-inline void NewSessionRequest::set_deviceos(const std::string& value) {
- _internal_set_deviceos(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS)
+inline void GetResponse::set_fromdeviceid(const std::string& value) {
+ _internal_set_fromdeviceid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
}
-inline std::string* NewSessionRequest::mutable_deviceos() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS)
- return _internal_mutable_deviceos();
+inline std::string* GetResponse::mutable_fromdeviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
+ return _internal_mutable_fromdeviceid();
}
-inline const std::string& NewSessionRequest::_internal_deviceos() const {
- return deviceos_.Get();
+inline const std::string& GetResponse::_internal_fromdeviceid() const {
+ return fromdeviceid_.Get();
}
-inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) {
+inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {
- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionRequest::set_deviceos(std::string&& value) {
+inline void GetResponse::set_fromdeviceid(std::string&& value) {
- deviceos_.Set(
+ fromdeviceid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
}
-inline void NewSessionRequest::set_deviceos(const char* value) {
+inline void GetResponse::set_fromdeviceid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS)
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
}
-inline void NewSessionRequest::set_deviceos(const char* value,
+inline void GetResponse::set_fromdeviceid(const char* value,
size_t size) {
- deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
}
-inline std::string* NewSessionRequest::_internal_mutable_deviceos() {
+inline std::string* GetResponse::_internal_mutable_fromdeviceid() {
- return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionRequest::release_deviceos() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS)
- return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetResponse::release_fromdeviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
+ return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) {
- if (deviceos != nullptr) {
+inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
+ if (fromdeviceid != nullptr) {
} else {
}
- deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos,
+ fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
}
-// -------------------------------------------------------------------
-
-// NewSessionResponse
-
-// string sessionID = 1;
-inline void NewSessionResponse::clear_sessionid() {
- sessionid_.ClearToEmpty();
+// bytes payload = 2;
+inline void GetResponse::clear_payload() {
+ payload_.ClearToEmpty();
}
-inline const std::string& NewSessionResponse::sessionid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID)
- return _internal_sessionid();
+inline const std::string& GetResponse::payload() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
+ return _internal_payload();
}
-inline void NewSessionResponse::set_sessionid(const std::string& value) {
- _internal_set_sessionid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID)
+inline void GetResponse::set_payload(const std::string& value) {
+ _internal_set_payload(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
}
-inline std::string* NewSessionResponse::mutable_sessionid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID)
- return _internal_mutable_sessionid();
+inline std::string* GetResponse::mutable_payload() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
+ return _internal_mutable_payload();
}
-inline const std::string& NewSessionResponse::_internal_sessionid() const {
- return sessionid_.Get();
+inline const std::string& GetResponse::_internal_payload() const {
+ return payload_.Get();
}
-inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) {
+inline void GetResponse::_internal_set_payload(const std::string& value) {
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void NewSessionResponse::set_sessionid(std::string&& value) {
+inline void GetResponse::set_payload(std::string&& value) {
- sessionid_.Set(
+ payload_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
}
-inline void NewSessionResponse::set_sessionid(const char* value) {
+inline void GetResponse::set_payload(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID)
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
}
-inline void NewSessionResponse::set_sessionid(const char* value,
+inline void GetResponse::set_payload(const void* value,
size_t size) {
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
}
-inline std::string* NewSessionResponse::_internal_mutable_sessionid() {
+inline std::string* GetResponse::_internal_mutable_payload() {
- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* NewSessionResponse::release_sessionid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID)
- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* GetResponse::release_payload() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
+ return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) {
- if (sessionid != nullptr) {
+inline void GetResponse::set_allocated_payload(std::string* payload) {
+ if (payload != nullptr) {
} else {
}
- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+ payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
}
-// -------------------------------------------------------------------
-
-// SendRequest
-
-// string sessionID = 1;
-inline void SendRequest::clear_sessionid() {
- sessionid_.ClearToEmpty();
+// repeated string blobHashes = 3;
+inline int GetResponse::_internal_blobhashes_size() const {
+ return blobhashes_.size();
}
-inline const std::string& SendRequest::sessionid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID)
- return _internal_sessionid();
+inline int GetResponse::blobhashes_size() const {
+ return _internal_blobhashes_size();
}
-inline void SendRequest::set_sessionid(const std::string& value) {
- _internal_set_sessionid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID)
+inline void GetResponse::clear_blobhashes() {
+ blobhashes_.Clear();
}
-inline std::string* SendRequest::mutable_sessionid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID)
- return _internal_mutable_sessionid();
+inline std::string* GetResponse::add_blobhashes() {
+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
+ return _internal_add_blobhashes();
}
-inline const std::string& SendRequest::_internal_sessionid() const {
- return sessionid_.Get();
+inline const std::string& GetResponse::_internal_blobhashes(int index) const {
+ return blobhashes_.Get(index);
}
-inline void SendRequest::_internal_set_sessionid(const std::string& value) {
-
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+inline const std::string& GetResponse::blobhashes(int index) const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
+ return _internal_blobhashes(index);
}
-inline void SendRequest::set_sessionid(std::string&& value) {
-
- sessionid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID)
+inline std::string* GetResponse::mutable_blobhashes(int index) {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
+ return blobhashes_.Mutable(index);
}
-inline void SendRequest::set_sessionid(const char* value) {
+inline void GetResponse::set_blobhashes(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+ blobhashes_.Mutable(index)->assign(value);
+}
+inline void GetResponse::set_blobhashes(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+ blobhashes_.Mutable(index)->assign(std::move(value));
+}
+inline void GetResponse::set_blobhashes(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
-
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID)
+ blobhashes_.Mutable(index)->assign(value);
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
}
-inline void SendRequest::set_sessionid(const char* value,
- size_t size) {
-
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID)
+inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
+ blobhashes_.Mutable(index)->assign(
+ reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
+}
+inline std::string* GetResponse::_internal_add_blobhashes() {
+ return blobhashes_.Add();
+}
+inline void GetResponse::add_blobhashes(const std::string& value) {
+ blobhashes_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+}
+inline void GetResponse::add_blobhashes(std::string&& value) {
+ blobhashes_.Add(std::move(value));
+ // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
}
-inline std::string* SendRequest::_internal_mutable_sessionid() {
-
- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+inline void GetResponse::add_blobhashes(const char* value) {
+ GOOGLE_DCHECK(value != nullptr);
+ blobhashes_.Add()->assign(value);
+ // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
}
-inline std::string* SendRequest::release_sessionid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID)
- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline void GetResponse::add_blobhashes(const char* value, size_t size) {
+ blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
}
-inline void SendRequest::set_allocated_sessionid(std::string* sessionid) {
- if (sessionid != nullptr) {
-
- } else {
-
- }
- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID)
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+GetResponse::blobhashes() const {
+ // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
+ return blobhashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+GetResponse::mutable_blobhashes() {
+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
+ return &blobhashes_;
}
-// string toDeviceID = 2;
-inline void SendRequest::clear_todeviceid() {
+// -------------------------------------------------------------------
+
+// OutboundMessage
+
+// string toDeviceID = 1;
+inline void OutboundMessage::clear_todeviceid() {
todeviceid_.ClearToEmpty();
}
-inline const std::string& SendRequest::todeviceid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID)
+inline const std::string& OutboundMessage::todeviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.toDeviceID)
return _internal_todeviceid();
}
-inline void SendRequest::set_todeviceid(const std::string& value) {
+inline void OutboundMessage::set_todeviceid(const std::string& value) {
_internal_set_todeviceid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID)
+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.toDeviceID)
}
-inline std::string* SendRequest::mutable_todeviceid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID)
+inline std::string* OutboundMessage::mutable_todeviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.toDeviceID)
return _internal_mutable_todeviceid();
}
-inline const std::string& SendRequest::_internal_todeviceid() const {
+inline const std::string& OutboundMessage::_internal_todeviceid() const {
return todeviceid_.Get();
}
-inline void SendRequest::_internal_set_todeviceid(const std::string& value) {
+inline void OutboundMessage::_internal_set_todeviceid(const std::string& value) {
todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void SendRequest::set_todeviceid(std::string&& value) {
+inline void OutboundMessage::set_todeviceid(std::string&& value) {
todeviceid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.toDeviceID)
}
-inline void SendRequest::set_todeviceid(const char* value) {
+inline void OutboundMessage::set_todeviceid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID)
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.toDeviceID)
}
-inline void SendRequest::set_todeviceid(const char* value,
+inline void OutboundMessage::set_todeviceid(const char* value,
size_t size) {
todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.toDeviceID)
}
-inline std::string* SendRequest::_internal_mutable_todeviceid() {
+inline std::string* OutboundMessage::_internal_mutable_todeviceid() {
return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* SendRequest::release_todeviceid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID)
+inline std::string* OutboundMessage::release_todeviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.toDeviceID)
return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) {
+inline void OutboundMessage::set_allocated_todeviceid(std::string* todeviceid) {
if (todeviceid != nullptr) {
} else {
@@ -2902,60 +3769,60 @@
}
todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.toDeviceID)
}
-// bytes payload = 3;
-inline void SendRequest::clear_payload() {
+// string payload = 2;
+inline void OutboundMessage::clear_payload() {
payload_.ClearToEmpty();
}
-inline const std::string& SendRequest::payload() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload)
+inline const std::string& OutboundMessage::payload() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.payload)
return _internal_payload();
}
-inline void SendRequest::set_payload(const std::string& value) {
+inline void OutboundMessage::set_payload(const std::string& value) {
_internal_set_payload(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload)
+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.payload)
}
-inline std::string* SendRequest::mutable_payload() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload)
+inline std::string* OutboundMessage::mutable_payload() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.payload)
return _internal_mutable_payload();
}
-inline const std::string& SendRequest::_internal_payload() const {
+inline const std::string& OutboundMessage::_internal_payload() const {
return payload_.Get();
}
-inline void SendRequest::_internal_set_payload(const std::string& value) {
+inline void OutboundMessage::_internal_set_payload(const std::string& value) {
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void SendRequest::set_payload(std::string&& value) {
+inline void OutboundMessage::set_payload(std::string&& value) {
payload_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.OutboundMessage.payload)
}
-inline void SendRequest::set_payload(const char* value) {
+inline void OutboundMessage::set_payload(const char* value) {
GOOGLE_DCHECK(value != nullptr);
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload)
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.payload)
}
-inline void SendRequest::set_payload(const void* value,
+inline void OutboundMessage::set_payload(const char* value,
size_t size) {
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.payload)
}
-inline std::string* SendRequest::_internal_mutable_payload() {
+inline std::string* OutboundMessage::_internal_mutable_payload() {
return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* SendRequest::release_payload() {
- // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload)
+inline std::string* OutboundMessage::release_payload() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.OutboundMessage.payload)
return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void SendRequest::set_allocated_payload(std::string* payload) {
+inline void OutboundMessage::set_allocated_payload(std::string* payload) {
if (payload != nullptr) {
} else {
@@ -2963,264 +3830,260 @@
}
payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.OutboundMessage.payload)
}
-// repeated string blobHashes = 4;
-inline int SendRequest::_internal_blobhashes_size() const {
+// repeated string blobHashes = 3;
+inline int OutboundMessage::_internal_blobhashes_size() const {
return blobhashes_.size();
}
-inline int SendRequest::blobhashes_size() const {
+inline int OutboundMessage::blobhashes_size() const {
return _internal_blobhashes_size();
}
-inline void SendRequest::clear_blobhashes() {
+inline void OutboundMessage::clear_blobhashes() {
blobhashes_.Clear();
}
-inline std::string* SendRequest::add_blobhashes() {
- // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes)
+inline std::string* OutboundMessage::add_blobhashes() {
+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.OutboundMessage.blobHashes)
return _internal_add_blobhashes();
}
-inline const std::string& SendRequest::_internal_blobhashes(int index) const {
+inline const std::string& OutboundMessage::_internal_blobhashes(int index) const {
return blobhashes_.Get(index);
}
-inline const std::string& SendRequest::blobhashes(int index) const {
- // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes)
+inline const std::string& OutboundMessage::blobhashes(int index) const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.OutboundMessage.blobHashes)
return _internal_blobhashes(index);
}
-inline std::string* SendRequest::mutable_blobhashes(int index) {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes)
+inline std::string* OutboundMessage::mutable_blobhashes(int index) {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.OutboundMessage.blobHashes)
return blobhashes_.Mutable(index);
}
-inline void SendRequest::set_blobhashes(int index, const std::string& value) {
- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+inline void OutboundMessage::set_blobhashes(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
blobhashes_.Mutable(index)->assign(value);
}
-inline void SendRequest::set_blobhashes(int index, std::string&& value) {
- // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes)
+inline void OutboundMessage::set_blobhashes(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.OutboundMessage.blobHashes)
blobhashes_.Mutable(index)->assign(std::move(value));
}
-inline void SendRequest::set_blobhashes(int index, const char* value) {
+inline void OutboundMessage::set_blobhashes(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
blobhashes_.Mutable(index)->assign(value);
- // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.OutboundMessage.blobHashes)
}
-inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) {
+inline void OutboundMessage::set_blobhashes(int index, const char* value, size_t size) {
blobhashes_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.OutboundMessage.blobHashes)
}
-inline std::string* SendRequest::_internal_add_blobhashes() {
+inline std::string* OutboundMessage::_internal_add_blobhashes() {
return blobhashes_.Add();
}
-inline void SendRequest::add_blobhashes(const std::string& value) {
+inline void OutboundMessage::add_blobhashes(const std::string& value) {
blobhashes_.Add()->assign(value);
- // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
}
-inline void SendRequest::add_blobhashes(std::string&& value) {
+inline void OutboundMessage::add_blobhashes(std::string&& value) {
blobhashes_.Add(std::move(value));
- // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_add:tunnelbroker.OutboundMessage.blobHashes)
}
-inline void SendRequest::add_blobhashes(const char* value) {
+inline void OutboundMessage::add_blobhashes(const char* value) {
GOOGLE_DCHECK(value != nullptr);
blobhashes_.Add()->assign(value);
- // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_add_char:tunnelbroker.OutboundMessage.blobHashes)
}
-inline void SendRequest::add_blobhashes(const char* value, size_t size) {
+inline void OutboundMessage::add_blobhashes(const char* value, size_t size) {
blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
- // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes)
+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.OutboundMessage.blobHashes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-SendRequest::blobhashes() const {
- // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes)
+OutboundMessage::blobhashes() const {
+ // @@protoc_insertion_point(field_list:tunnelbroker.OutboundMessage.blobHashes)
return blobhashes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-SendRequest::mutable_blobhashes() {
- // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes)
+OutboundMessage::mutable_blobhashes() {
+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.OutboundMessage.blobHashes)
return &blobhashes_;
}
// -------------------------------------------------------------------
-// GetRequest
+// InboundMessage
-// string sessionID = 1;
-inline void GetRequest::clear_sessionid() {
- sessionid_.ClearToEmpty();
+// string fromDeviceID = 1;
+inline void InboundMessage::clear_fromdeviceid() {
+ fromdeviceid_.ClearToEmpty();
}
-inline const std::string& GetRequest::sessionid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID)
- return _internal_sessionid();
+inline const std::string& InboundMessage::fromdeviceid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromDeviceID)
+ return _internal_fromdeviceid();
}
-inline void GetRequest::set_sessionid(const std::string& value) {
- _internal_set_sessionid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID)
+inline void InboundMessage::set_fromdeviceid(const std::string& value) {
+ _internal_set_fromdeviceid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromDeviceID)
}
-inline std::string* GetRequest::mutable_sessionid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID)
- return _internal_mutable_sessionid();
+inline std::string* InboundMessage::mutable_fromdeviceid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromDeviceID)
+ return _internal_mutable_fromdeviceid();
}
-inline const std::string& GetRequest::_internal_sessionid() const {
- return sessionid_.Get();
+inline const std::string& InboundMessage::_internal_fromdeviceid() const {
+ return fromdeviceid_.Get();
}
-inline void GetRequest::_internal_set_sessionid(const std::string& value) {
+inline void InboundMessage::_internal_set_fromdeviceid(const std::string& value) {
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void GetRequest::set_sessionid(std::string&& value) {
+inline void InboundMessage::set_fromdeviceid(std::string&& value) {
- sessionid_.Set(
+ fromdeviceid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromDeviceID)
}
-inline void GetRequest::set_sessionid(const char* value) {
+inline void InboundMessage::set_fromdeviceid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID)
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromDeviceID)
}
-inline void GetRequest::set_sessionid(const char* value,
+inline void InboundMessage::set_fromdeviceid(const char* value,
size_t size) {
- sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromDeviceID)
}
-inline std::string* GetRequest::_internal_mutable_sessionid() {
+inline std::string* InboundMessage::_internal_mutable_fromdeviceid() {
- return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* GetRequest::release_sessionid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID)
- return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* InboundMessage::release_fromdeviceid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromDeviceID)
+ return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void GetRequest::set_allocated_sessionid(std::string* sessionid) {
- if (sessionid != nullptr) {
+inline void InboundMessage::set_allocated_fromdeviceid(std::string* fromdeviceid) {
+ if (fromdeviceid != nullptr) {
} else {
}
- sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid,
+ fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromDeviceID)
}
-// -------------------------------------------------------------------
-
-// GetResponse
-
-// string fromDeviceID = 1;
-inline void GetResponse::clear_fromdeviceid() {
- fromdeviceid_.ClearToEmpty();
+// string fromConnectionID = 2;
+inline void InboundMessage::clear_fromconnectionid() {
+ fromconnectionid_.ClearToEmpty();
}
-inline const std::string& GetResponse::fromdeviceid() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.fromDeviceID)
- return _internal_fromdeviceid();
+inline const std::string& InboundMessage::fromconnectionid() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.fromConnectionID)
+ return _internal_fromconnectionid();
}
-inline void GetResponse::set_fromdeviceid(const std::string& value) {
- _internal_set_fromdeviceid(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.fromDeviceID)
+inline void InboundMessage::set_fromconnectionid(const std::string& value) {
+ _internal_set_fromconnectionid(value);
+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.fromConnectionID)
}
-inline std::string* GetResponse::mutable_fromdeviceid() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.fromDeviceID)
- return _internal_mutable_fromdeviceid();
+inline std::string* InboundMessage::mutable_fromconnectionid() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.fromConnectionID)
+ return _internal_mutable_fromconnectionid();
}
-inline const std::string& GetResponse::_internal_fromdeviceid() const {
- return fromdeviceid_.Get();
+inline const std::string& InboundMessage::_internal_fromconnectionid() const {
+ return fromconnectionid_.Get();
}
-inline void GetResponse::_internal_set_fromdeviceid(const std::string& value) {
+inline void InboundMessage::_internal_set_fromconnectionid(const std::string& value) {
- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void GetResponse::set_fromdeviceid(std::string&& value) {
+inline void InboundMessage::set_fromconnectionid(std::string&& value) {
- fromdeviceid_.Set(
+ fromconnectionid_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.fromDeviceID)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.fromConnectionID)
}
-inline void GetResponse::set_fromdeviceid(const char* value) {
+inline void InboundMessage::set_fromconnectionid(const char* value) {
GOOGLE_DCHECK(value != nullptr);
- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.fromDeviceID)
+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.fromConnectionID)
}
-inline void GetResponse::set_fromdeviceid(const char* value,
+inline void InboundMessage::set_fromconnectionid(const char* value,
size_t size) {
- fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.fromDeviceID)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.fromConnectionID)
}
-inline std::string* GetResponse::_internal_mutable_fromdeviceid() {
+inline std::string* InboundMessage::_internal_mutable_fromconnectionid() {
- return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
+ return fromconnectionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* GetResponse::release_fromdeviceid() {
- // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.fromDeviceID)
- return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+inline std::string* InboundMessage::release_fromconnectionid() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.fromConnectionID)
+ return fromconnectionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void GetResponse::set_allocated_fromdeviceid(std::string* fromdeviceid) {
- if (fromdeviceid != nullptr) {
+inline void InboundMessage::set_allocated_fromconnectionid(std::string* fromconnectionid) {
+ if (fromconnectionid != nullptr) {
} else {
}
- fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid,
+ fromconnectionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromconnectionid,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.fromDeviceID)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.fromConnectionID)
}
-// bytes payload = 2;
-inline void GetResponse::clear_payload() {
+// string payload = 3;
+inline void InboundMessage::clear_payload() {
payload_.ClearToEmpty();
}
-inline const std::string& GetResponse::payload() const {
- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.payload)
+inline const std::string& InboundMessage::payload() const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.payload)
return _internal_payload();
}
-inline void GetResponse::set_payload(const std::string& value) {
+inline void InboundMessage::set_payload(const std::string& value) {
_internal_set_payload(value);
- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.payload)
+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.payload)
}
-inline std::string* GetResponse::mutable_payload() {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.payload)
+inline std::string* InboundMessage::mutable_payload() {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.payload)
return _internal_mutable_payload();
}
-inline const std::string& GetResponse::_internal_payload() const {
+inline const std::string& InboundMessage::_internal_payload() const {
return payload_.Get();
}
-inline void GetResponse::_internal_set_payload(const std::string& value) {
+inline void InboundMessage::_internal_set_payload(const std::string& value) {
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
-inline void GetResponse::set_payload(std::string&& value) {
+inline void InboundMessage::set_payload(std::string&& value) {
payload_.Set(
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponse.payload)
+ // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.InboundMessage.payload)
}
-inline void GetResponse::set_payload(const char* value) {
+inline void InboundMessage::set_payload(const char* value) {
GOOGLE_DCHECK(value != nullptr);
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.payload)
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.payload)
}
-inline void GetResponse::set_payload(const void* value,
+inline void InboundMessage::set_payload(const char* value,
size_t size) {
payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.payload)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.payload)
}
-inline std::string* GetResponse::_internal_mutable_payload() {
+inline std::string* InboundMessage::_internal_mutable_payload() {
return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
-inline std::string* GetResponse::release_payload() {
- // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.payload)
+inline std::string* InboundMessage::release_payload() {
+ // @@protoc_insertion_point(field_release:tunnelbroker.InboundMessage.payload)
return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
-inline void GetResponse::set_allocated_payload(std::string* payload) {
+inline void InboundMessage::set_allocated_payload(std::string* payload) {
if (payload != nullptr) {
} else {
@@ -3228,80 +4091,80 @@
}
payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
GetArena());
- // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.payload)
+ // @@protoc_insertion_point(field_set_allocated:tunnelbroker.InboundMessage.payload)
}
-// repeated string blobHashes = 3;
-inline int GetResponse::_internal_blobhashes_size() const {
+// repeated string blobHashes = 4;
+inline int InboundMessage::_internal_blobhashes_size() const {
return blobhashes_.size();
}
-inline int GetResponse::blobhashes_size() const {
+inline int InboundMessage::blobhashes_size() const {
return _internal_blobhashes_size();
}
-inline void GetResponse::clear_blobhashes() {
+inline void InboundMessage::clear_blobhashes() {
blobhashes_.Clear();
}
-inline std::string* GetResponse::add_blobhashes() {
- // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponse.blobHashes)
+inline std::string* InboundMessage::add_blobhashes() {
+ // @@protoc_insertion_point(field_add_mutable:tunnelbroker.InboundMessage.blobHashes)
return _internal_add_blobhashes();
}
-inline const std::string& GetResponse::_internal_blobhashes(int index) const {
+inline const std::string& InboundMessage::_internal_blobhashes(int index) const {
return blobhashes_.Get(index);
}
-inline const std::string& GetResponse::blobhashes(int index) const {
- // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.blobHashes)
+inline const std::string& InboundMessage::blobhashes(int index) const {
+ // @@protoc_insertion_point(field_get:tunnelbroker.InboundMessage.blobHashes)
return _internal_blobhashes(index);
}
-inline std::string* GetResponse::mutable_blobhashes(int index) {
- // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.blobHashes)
+inline std::string* InboundMessage::mutable_blobhashes(int index) {
+ // @@protoc_insertion_point(field_mutable:tunnelbroker.InboundMessage.blobHashes)
return blobhashes_.Mutable(index);
}
-inline void GetResponse::set_blobhashes(int index, const std::string& value) {
- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+inline void InboundMessage::set_blobhashes(int index, const std::string& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
blobhashes_.Mutable(index)->assign(value);
}
-inline void GetResponse::set_blobhashes(int index, std::string&& value) {
- // @@protoc_insertion_point(field_set:tunnelbroker.GetResponse.blobHashes)
+inline void InboundMessage::set_blobhashes(int index, std::string&& value) {
+ // @@protoc_insertion_point(field_set:tunnelbroker.InboundMessage.blobHashes)
blobhashes_.Mutable(index)->assign(std::move(value));
}
-inline void GetResponse::set_blobhashes(int index, const char* value) {
+inline void InboundMessage::set_blobhashes(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
blobhashes_.Mutable(index)->assign(value);
- // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_set_char:tunnelbroker.InboundMessage.blobHashes)
}
-inline void GetResponse::set_blobhashes(int index, const char* value, size_t size) {
+inline void InboundMessage::set_blobhashes(int index, const char* value, size_t size) {
blobhashes_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
- // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_set_pointer:tunnelbroker.InboundMessage.blobHashes)
}
-inline std::string* GetResponse::_internal_add_blobhashes() {
+inline std::string* InboundMessage::_internal_add_blobhashes() {
return blobhashes_.Add();
}
-inline void GetResponse::add_blobhashes(const std::string& value) {
+inline void InboundMessage::add_blobhashes(const std::string& value) {
blobhashes_.Add()->assign(value);
- // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
}
-inline void GetResponse::add_blobhashes(std::string&& value) {
+inline void InboundMessage::add_blobhashes(std::string&& value) {
blobhashes_.Add(std::move(value));
- // @@protoc_insertion_point(field_add:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_add:tunnelbroker.InboundMessage.blobHashes)
}
-inline void GetResponse::add_blobhashes(const char* value) {
+inline void InboundMessage::add_blobhashes(const char* value) {
GOOGLE_DCHECK(value != nullptr);
blobhashes_.Add()->assign(value);
- // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_add_char:tunnelbroker.InboundMessage.blobHashes)
}
-inline void GetResponse::add_blobhashes(const char* value, size_t size) {
+inline void InboundMessage::add_blobhashes(const char* value, size_t size) {
blobhashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
- // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponse.blobHashes)
+ // @@protoc_insertion_point(field_add_pointer:tunnelbroker.InboundMessage.blobHashes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
-GetResponse::blobhashes() const {
- // @@protoc_insertion_point(field_list:tunnelbroker.GetResponse.blobHashes)
+InboundMessage::blobhashes() const {
+ // @@protoc_insertion_point(field_list:tunnelbroker.InboundMessage.blobHashes)
return blobhashes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
-GetResponse::mutable_blobhashes() {
- // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponse.blobHashes)
+InboundMessage::mutable_blobhashes() {
+ // @@protoc_insertion_point(field_mutable_list:tunnelbroker.InboundMessage.blobHashes)
return &blobhashes_;
}
@@ -3756,6 +4619,10 @@
// -------------------------------------------------------------------
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
// @@protoc_insertion_point(namespace_scope)
diff --git a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
--- a/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
+++ b/native/cpp/CommonCpp/grpc/_generated/tunnelbroker.pb.cc
@@ -113,6 +113,35 @@
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseDefaultTypeInternal _GetResponse_default_instance_;
+constexpr OutboundMessage::OutboundMessage(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : blobhashes_()
+ , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct OutboundMessageDefaultTypeInternal {
+ constexpr OutboundMessageDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~OutboundMessageDefaultTypeInternal() {}
+ union {
+ OutboundMessage _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OutboundMessageDefaultTypeInternal _OutboundMessage_default_instance_;
+constexpr InboundMessage::InboundMessage(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : blobhashes_()
+ , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , fromconnectionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct InboundMessageDefaultTypeInternal {
+ constexpr InboundMessageDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~InboundMessageDefaultTypeInternal() {}
+ union {
+ InboundMessage _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InboundMessageDefaultTypeInternal _InboundMessage_default_instance_;
constexpr CheckRequest::CheckRequest(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
@@ -178,7 +207,7 @@
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PongRequestDefaultTypeInternal _PongRequest_default_instance_;
} // namespace tunnelbroker
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[12];
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[14];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_tunnelbroker_2eproto[2];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_tunnelbroker_2eproto = nullptr;
@@ -244,6 +273,23 @@
PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, payload_),
PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, blobhashes_),
~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, todeviceid_),
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, payload_),
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::OutboundMessage, blobhashes_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromdeviceid_),
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, fromconnectionid_),
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, payload_),
+ PROTOBUF_FIELD_OFFSET(::tunnelbroker::InboundMessage, blobhashes_),
+ ~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
@@ -285,11 +331,13 @@
{ 37, -1, sizeof(::tunnelbroker::SendRequest)},
{ 46, -1, sizeof(::tunnelbroker::GetRequest)},
{ 52, -1, sizeof(::tunnelbroker::GetResponse)},
- { 60, -1, sizeof(::tunnelbroker::CheckRequest)},
- { 67, -1, sizeof(::tunnelbroker::CheckResponse)},
- { 73, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
- { 80, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
- { 86, -1, sizeof(::tunnelbroker::PongRequest)},
+ { 60, -1, sizeof(::tunnelbroker::OutboundMessage)},
+ { 68, -1, sizeof(::tunnelbroker::InboundMessage)},
+ { 77, -1, sizeof(::tunnelbroker::CheckRequest)},
+ { 84, -1, sizeof(::tunnelbroker::CheckResponse)},
+ { 90, -1, sizeof(::tunnelbroker::NewPrimaryRequest)},
+ { 97, -1, sizeof(::tunnelbroker::NewPrimaryResponse)},
+ { 103, -1, sizeof(::tunnelbroker::PongRequest)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
@@ -300,6 +348,8 @@
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_SendRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_GetResponse_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_OutboundMessage_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_InboundMessage_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_CheckResponse_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::tunnelbroker::_NewPrimaryRequest_default_instance_),
@@ -313,7 +363,7 @@
"ureRequest\022\020\n\010deviceID\030\001 \001(\t\"*\n\030SessionS"
"ignatureResponse\022\016\n\006toSign\030\001 \001(\t\"\225\002\n\021New"
"SessionRequest\022\020\n\010deviceID\030\001 \001(\t\022\021\n\tpubl"
- "icKey\030\002 \001(\014\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
+ "icKey\030\002 \001(\t\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify"
"Token\030\004 \001(\tH\000\210\001\001\022\?\n\ndeviceType\030\005 \001(\0162+.t"
"unnelbroker.NewSessionRequest.DeviceType"
"s\022\030\n\020deviceAppVersion\030\006 \001(\t\022\020\n\010deviceOS\030"
@@ -324,40 +374,46 @@
"D\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\022\022\n\nblobHashes\030\004"
" \003(\t\"\037\n\nGetRequest\022\021\n\tsessionID\030\001 \001(\t\"H\n"
"\013GetResponse\022\024\n\014fromDeviceID\030\001 \001(\t\022\017\n\007pa"
- "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"3\n\014Check"
- "Request\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002"
- " \001(\t\"K\n\rCheckResponse\022:\n\021checkResponseTy"
- "pe\030\001 \001(\0162\037.tunnelbroker.CheckResponseTyp"
- "e\"8\n\021NewPrimaryRequest\022\016\n\006userId\030\001 \001(\t\022\023"
- "\n\013deviceToken\030\002 \001(\t\"%\n\022NewPrimaryRespons"
- "e\022\017\n\007success\030\001 \001(\010\"2\n\013PongRequest\022\016\n\006use"
- "rId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t*n\n\021CheckR"
- "esponseType\022\030\n\024PRIMARY_DOESNT_EXIST\020\000\022\022\n"
- "\016PRIMARY_ONLINE\020\001\022\023\n\017PRIMARY_OFFLINE\020\002\022\026"
- "\n\022CURRENT_IS_PRIMARY\020\0032\303\004\n\023TunnelbrokerS"
- "ervice\022W\n\032CheckIfPrimaryDeviceOnline\022\032.t"
- "unnelbroker.CheckRequest\032\033.tunnelbroker."
- "CheckResponse\"\000\022]\n\026BecomeNewPrimaryDevic"
- "e\022\037.tunnelbroker.NewPrimaryRequest\032 .tun"
- "nelbroker.NewPrimaryResponse\"\000\022\?\n\010SendPo"
- "ng\022\031.tunnelbroker.PongRequest\032\026.google.p"
- "rotobuf.Empty\"\000\022c\n\020SessionSignature\022%.tu"
- "nnelbroker.SessionSignatureRequest\032&.tun"
- "nelbroker.SessionSignatureResponse\"\000\022Q\n\n"
- "NewSession\022\037.tunnelbroker.NewSessionRequ"
- "est\032 .tunnelbroker.NewSessionResponse\"\000\022"
- ";\n\004Send\022\031.tunnelbroker.SendRequest\032\026.goo"
- "gle.protobuf.Empty\"\000\022>\n\003Get\022\030.tunnelbrok"
- "er.GetRequest\032\031.tunnelbroker.GetResponse"
- "\"\0000\001b\006proto3"
+ "yload\030\002 \001(\014\022\022\n\nblobHashes\030\003 \003(\t\"J\n\017Outbo"
+ "undMessage\022\022\n\ntoDeviceID\030\001 \001(\t\022\017\n\007payloa"
+ "d\030\002 \001(\t\022\022\n\nblobHashes\030\003 \003(\t\"e\n\016InboundMe"
+ "ssage\022\024\n\014fromDeviceID\030\001 \001(\t\022\030\n\020fromConne"
+ "ctionID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\nblobHa"
+ "shes\030\004 \003(\t\"3\n\014CheckRequest\022\016\n\006userId\030\001 \001"
+ "(\t\022\023\n\013deviceToken\030\002 \001(\t\"K\n\rCheckResponse"
+ "\022:\n\021checkResponseType\030\001 \001(\0162\037.tunnelbrok"
+ "er.CheckResponseType\"8\n\021NewPrimaryReques"
+ "t\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%"
+ "\n\022NewPrimaryResponse\022\017\n\007success\030\001 \001(\010\"2\n"
+ "\013PongRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceTo"
+ "ken\030\002 \001(\t*n\n\021CheckResponseType\022\030\n\024PRIMAR"
+ "Y_DOESNT_EXIST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017"
+ "PRIMARY_OFFLINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020"
+ "\0032\224\005\n\023TunnelbrokerService\022W\n\032CheckIfPrim"
+ "aryDeviceOnline\022\032.tunnelbroker.CheckRequ"
+ "est\032\033.tunnelbroker.CheckResponse\"\000\022]\n\026Be"
+ "comeNewPrimaryDevice\022\037.tunnelbroker.NewP"
+ "rimaryRequest\032 .tunnelbroker.NewPrimaryR"
+ "esponse\"\000\022\?\n\010SendPong\022\031.tunnelbroker.Pon"
+ "gRequest\032\026.google.protobuf.Empty\"\000\022c\n\020Se"
+ "ssionSignature\022%.tunnelbroker.SessionSig"
+ "natureRequest\032&.tunnelbroker.SessionSign"
+ "atureResponse\"\000\022Q\n\nNewSession\022\037.tunnelbr"
+ "oker.NewSessionRequest\032 .tunnelbroker.Ne"
+ "wSessionResponse\"\000\022;\n\004Send\022\031.tunnelbroke"
+ "r.SendRequest\032\026.google.protobuf.Empty\"\000\022"
+ ">\n\003Get\022\030.tunnelbroker.GetRequest\032\031.tunne"
+ "lbroker.GetResponse\"\0000\001\022O\n\nOpenStream\022\035."
+ "tunnelbroker.OutboundMessage\032\034.tunnelbro"
+ "ker.InboundMessage\"\000(\0010\001b\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_tunnelbroker_2eproto_deps[1] = {
&::descriptor_table_google_2fprotobuf_2fempty_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_tunnelbroker_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tunnelbroker_2eproto = {
- false, false, 1652, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto",
- &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 12,
+ false, false, 1912, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto",
+ &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 14,
schemas, file_default_instances, TableStruct_tunnelbroker_2eproto::offsets,
file_level_metadata_tunnelbroker_2eproto, file_level_enum_descriptors_tunnelbroker_2eproto, file_level_service_descriptors_tunnelbroker_2eproto,
};
@@ -937,11 +993,12 @@
CHK_(ptr);
} else goto handle_unusual;
continue;
- // bytes publicKey = 2;
+ // string publicKey = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
auto str = _internal_mutable_publickey();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.publicKey"));
CHK_(ptr);
} else goto handle_unusual;
continue;
@@ -1028,9 +1085,13 @@
1, this->_internal_deviceid(), target);
}
- // bytes publicKey = 2;
+ // string publicKey = 2;
if (this->publickey().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_publickey().data(), static_cast<int>(this->_internal_publickey().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.NewSessionRequest.publicKey");
+ target = stream->WriteStringMaybeAliased(
2, this->_internal_publickey(), target);
}
@@ -1104,10 +1165,10 @@
this->_internal_deviceid());
}
- // bytes publicKey = 2;
+ // string publicKey = 2;
if (this->publickey().size() > 0) {
total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_publickey());
}
@@ -2214,6 +2275,594 @@
}
+// ===================================================================
+
+class OutboundMessage::_Internal {
+ public:
+};
+
+OutboundMessage::OutboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena),
+ blobhashes_(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:tunnelbroker.OutboundMessage)
+}
+OutboundMessage::OutboundMessage(const OutboundMessage& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ blobhashes_(from.blobhashes_) {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_todeviceid().empty()) {
+ todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(),
+ GetArena());
+ }
+ payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_payload().empty()) {
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:tunnelbroker.OutboundMessage)
+}
+
+void OutboundMessage::SharedCtor() {
+todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+OutboundMessage::~OutboundMessage() {
+ // @@protoc_insertion_point(destructor:tunnelbroker.OutboundMessage)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void OutboundMessage::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void OutboundMessage::ArenaDtor(void* object) {
+ OutboundMessage* _this = reinterpret_cast< OutboundMessage* >(object);
+ (void)_this;
+}
+void OutboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void OutboundMessage::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void OutboundMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:tunnelbroker.OutboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ blobhashes_.Clear();
+ todeviceid_.ClearToEmpty();
+ payload_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* OutboundMessage::_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 toDeviceID = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_todeviceid();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.toDeviceID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string payload = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_payload();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.payload"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated string blobHashes = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_blobhashes();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.OutboundMessage.blobHashes"));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(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* OutboundMessage::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.OutboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string toDeviceID = 1;
+ if (this->todeviceid().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_todeviceid().data(), static_cast<int>(this->_internal_todeviceid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.OutboundMessage.toDeviceID");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_todeviceid(), target);
+ }
+
+ // string payload = 2;
+ if (this->payload().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.OutboundMessage.payload");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_payload(), target);
+ }
+
+ // repeated string blobHashes = 3;
+ for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
+ const auto& s = this->_internal_blobhashes(i);
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ s.data(), static_cast<int>(s.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.OutboundMessage.blobHashes");
+ target = stream->WriteString(3, s, 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:tunnelbroker.OutboundMessage)
+ return target;
+}
+
+size_t OutboundMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.OutboundMessage)
+ 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;
+
+ // repeated string blobHashes = 3;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
+ for (int i = 0, n = blobhashes_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ blobhashes_.Get(i));
+ }
+
+ // string toDeviceID = 1;
+ if (this->todeviceid().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_todeviceid());
+ }
+
+ // string payload = 2;
+ if (this->payload().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_payload());
+ }
+
+ 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 OutboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.OutboundMessage)
+ GOOGLE_DCHECK_NE(&from, this);
+ const OutboundMessage* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<OutboundMessage>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.OutboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.OutboundMessage)
+ MergeFrom(*source);
+ }
+}
+
+void OutboundMessage::MergeFrom(const OutboundMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.OutboundMessage)
+ 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;
+
+ blobhashes_.MergeFrom(from.blobhashes_);
+ if (from.todeviceid().size() > 0) {
+ _internal_set_todeviceid(from._internal_todeviceid());
+ }
+ if (from.payload().size() > 0) {
+ _internal_set_payload(from._internal_payload());
+ }
+}
+
+void OutboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.OutboundMessage)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void OutboundMessage::CopyFrom(const OutboundMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.OutboundMessage)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool OutboundMessage::IsInitialized() const {
+ return true;
+}
+
+void OutboundMessage::InternalSwap(OutboundMessage* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ blobhashes_.InternalSwap(&other->blobhashes_);
+ todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata OutboundMessage::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+class InboundMessage::_Internal {
+ public:
+};
+
+InboundMessage::InboundMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena),
+ blobhashes_(arena) {
+ SharedCtor();
+ RegisterArenaDtor(arena);
+ // @@protoc_insertion_point(arena_constructor:tunnelbroker.InboundMessage)
+}
+InboundMessage::InboundMessage(const InboundMessage& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ blobhashes_(from.blobhashes_) {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_fromdeviceid().empty()) {
+ fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(),
+ GetArena());
+ }
+ fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_fromconnectionid().empty()) {
+ fromconnectionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromconnectionid(),
+ GetArena());
+ }
+ payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ if (!from._internal_payload().empty()) {
+ payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(),
+ GetArena());
+ }
+ // @@protoc_insertion_point(copy_constructor:tunnelbroker.InboundMessage)
+}
+
+void InboundMessage::SharedCtor() {
+fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+fromconnectionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+InboundMessage::~InboundMessage() {
+ // @@protoc_insertion_point(destructor:tunnelbroker.InboundMessage)
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+void InboundMessage::SharedDtor() {
+ GOOGLE_DCHECK(GetArena() == nullptr);
+ fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ fromconnectionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void InboundMessage::ArenaDtor(void* object) {
+ InboundMessage* _this = reinterpret_cast< InboundMessage* >(object);
+ (void)_this;
+}
+void InboundMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void InboundMessage::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void InboundMessage::Clear() {
+// @@protoc_insertion_point(message_clear_start:tunnelbroker.InboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ blobhashes_.Clear();
+ fromdeviceid_.ClearToEmpty();
+ fromconnectionid_.ClearToEmpty();
+ payload_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* InboundMessage::_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 fromDeviceID = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+ auto str = _internal_mutable_fromdeviceid();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromDeviceID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string fromConnectionID = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+ auto str = _internal_mutable_fromconnectionid();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.fromConnectionID"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // string payload = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+ auto str = _internal_mutable_payload();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.payload"));
+ CHK_(ptr);
+ } else goto handle_unusual;
+ continue;
+ // repeated string blobHashes = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+ ptr -= 1;
+ do {
+ ptr += 1;
+ auto str = _internal_add_blobhashes();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.InboundMessage.blobHashes"));
+ CHK_(ptr);
+ if (!ctx->DataAvailable(ptr)) break;
+ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(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* InboundMessage::_InternalSerialize(
+ ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.InboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string fromDeviceID = 1;
+ if (this->fromdeviceid().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_fromdeviceid().data(), static_cast<int>(this->_internal_fromdeviceid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.InboundMessage.fromDeviceID");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_fromdeviceid(), target);
+ }
+
+ // string fromConnectionID = 2;
+ if (this->fromconnectionid().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_fromconnectionid().data(), static_cast<int>(this->_internal_fromconnectionid().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.InboundMessage.fromConnectionID");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_fromconnectionid(), target);
+ }
+
+ // string payload = 3;
+ if (this->payload().size() > 0) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_payload().data(), static_cast<int>(this->_internal_payload().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.InboundMessage.payload");
+ target = stream->WriteStringMaybeAliased(
+ 3, this->_internal_payload(), target);
+ }
+
+ // repeated string blobHashes = 4;
+ for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) {
+ const auto& s = this->_internal_blobhashes(i);
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ s.data(), static_cast<int>(s.length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "tunnelbroker.InboundMessage.blobHashes");
+ target = stream->WriteString(4, s, 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:tunnelbroker.InboundMessage)
+ return target;
+}
+
+size_t InboundMessage::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:tunnelbroker.InboundMessage)
+ 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;
+
+ // repeated string blobHashes = 4;
+ total_size += 1 *
+ ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size());
+ for (int i = 0, n = blobhashes_.size(); i < n; i++) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ blobhashes_.Get(i));
+ }
+
+ // string fromDeviceID = 1;
+ if (this->fromdeviceid().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_fromdeviceid());
+ }
+
+ // string fromConnectionID = 2;
+ if (this->fromconnectionid().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_fromconnectionid());
+ }
+
+ // string payload = 3;
+ if (this->payload().size() > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_payload());
+ }
+
+ 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 InboundMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.InboundMessage)
+ GOOGLE_DCHECK_NE(&from, this);
+ const InboundMessage* source =
+ ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<InboundMessage>(
+ &from);
+ if (source == nullptr) {
+ // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.InboundMessage)
+ ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+ } else {
+ // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.InboundMessage)
+ MergeFrom(*source);
+ }
+}
+
+void InboundMessage::MergeFrom(const InboundMessage& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.InboundMessage)
+ 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;
+
+ blobhashes_.MergeFrom(from.blobhashes_);
+ if (from.fromdeviceid().size() > 0) {
+ _internal_set_fromdeviceid(from._internal_fromdeviceid());
+ }
+ if (from.fromconnectionid().size() > 0) {
+ _internal_set_fromconnectionid(from._internal_fromconnectionid());
+ }
+ if (from.payload().size() > 0) {
+ _internal_set_payload(from._internal_payload());
+ }
+}
+
+void InboundMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.InboundMessage)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+void InboundMessage::CopyFrom(const InboundMessage& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.InboundMessage)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool InboundMessage::IsInitialized() const {
+ return true;
+}
+
+void InboundMessage::InternalSwap(InboundMessage* other) {
+ using std::swap;
+ _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
+ blobhashes_.InternalSwap(&other->blobhashes_);
+ fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ fromconnectionid_.Swap(&other->fromconnectionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+ payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata InboundMessage::GetMetadata() const {
+ return GetMetadataStatic();
+}
+
+
// ===================================================================
class CheckRequest::_Internal {
@@ -3329,6 +3978,12 @@
template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponse >(Arena* arena) {
return Arena::CreateMessageInternal< ::tunnelbroker::GetResponse >(arena);
}
+template<> PROTOBUF_NOINLINE ::tunnelbroker::OutboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::OutboundMessage >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::tunnelbroker::OutboundMessage >(arena);
+}
+template<> PROTOBUF_NOINLINE ::tunnelbroker::InboundMessage* Arena::CreateMaybeMessage< ::tunnelbroker::InboundMessage >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::tunnelbroker::InboundMessage >(arena);
+}
template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage< ::tunnelbroker::CheckRequest >(Arena* arena) {
return Arena::CreateMessageInternal< ::tunnelbroker::CheckRequest >(arena);
}
diff --git a/native/cpp/CommonCpp/grpc/protos/backup.proto b/native/cpp/CommonCpp/grpc/protos/backup.proto
--- a/native/cpp/CommonCpp/grpc/protos/backup.proto
+++ b/native/cpp/CommonCpp/grpc/protos/backup.proto
@@ -5,48 +5,120 @@
import "google/protobuf/empty.proto";
service BackupService {
- rpc ResetKey(stream ResetKeyRequest) returns (google.protobuf.Empty) {}
- rpc SendLog(SendLogRequest) returns (google.protobuf.Empty) {}
- rpc PullBackupKey(PullBackupKeyRequest) returns (PullBackupKeyResponse) {}
- rpc PullCompaction(PullCompactionRequest) returns (stream PullCompactionResponse) {}
+ rpc CreateNewBackup(stream CreateNewBackupRequest) returns (stream CreateNewBackupResponse) {}
+ rpc SendLog(stream SendLogRequest) returns (google.protobuf.Empty) {}
+ rpc RecoverBackupKey(stream RecoverBackupKeyRequest) returns (stream RecoverBackupKeyResponse) {}
+ rpc PullBackup(stream PullBackupRequest) returns (stream PullBackupResponse) {}
}
-// ResetKey
+// Helper types
-message ResetKeyRequest {
- string userId = 1;
+message PakeRegistrationRequestAndUserID {
+ string userID = 1;
+ bytes pakeRegistrationRequest = 2;
+}
+
+message PakeAuthenticationRequestData {
+ oneof data {
+ PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
+ bytes pakeRegistrationUpload = 2;
+ bytes pakeCredentialRequest = 3;
+ bytes pakeCredentialFinalization = 4;
+ bytes pakeClientMAC = 5;
+ }
+}
+
+message WalletAuthenticationRequestData {
+ string userID = 1;
+ string walletAddress = 2;
+ bytes signedMessage = 3;
+}
+
+message FullAuthenticationRequestData {
+ oneof data {
+ PakeAuthenticationRequestData pakeAuthenticationRequestData = 1;
+ WalletAuthenticationRequestData walletAuthenticationRequestData = 2;
+ }
+}
+
+message WalletAuthenticationResponseData {
+ bool success = 1;
+}
+
+message PakeAuthenticationResponseData {
+ oneof data {
+ bytes pakeRegistrationResponse = 1;
+ bool pakeRegistrationSuccess = 2;
+ bytes pakeCredentialResponse = 3;
+ bytes pakeServerMAC = 4;
+ }
+}
+
+message FullAuthenticationResponseData {
oneof data {
- bytes newKey = 2;
- bytes compactionChunk = 3;
+ PakeAuthenticationResponseData pakeAuthenticationResponseData = 1;
+ WalletAuthenticationResponseData walletAuthenticationResponseData = 2;
+ }
+}
+
+message SimpleAuthenticationRequestData {
+ string backupID = 1;
+ string userID = 2;
+}
+
+message BackupKeyEntropy {
+ oneof data {
+ bytes nonce = 1;
+ bytes rawMessage = 2;
+ }
+}
+
+// CreateNewBackup
+
+message CreateNewBackupRequest {
+ oneof data {
+ FullAuthenticationRequestData authenticationRequestData = 1;
+ BackupKeyEntropy backupKeyEntropy = 2;
+ bytes newCompactionChunk = 3;
+ }
+}
+
+message CreateNewBackupResponse {
+ oneof data {
+ FullAuthenticationResponseData authenticationResponseData = 1;
+ bool entropyValid = 2;
+ string backupID = 3;
}
}
// SendLog
message SendLogRequest {
- string userId = 1;
- bytes data = 2;
+ SimpleAuthenticationRequestData authenticationData = 1;
+ bytes logData = 2;
}
-// PullBackupKey
+// RecoverBackupKey
-message PullBackupKeyRequest {
- string userId = 1;
- bytes pakeKey = 2;
+message RecoverBackupKeyRequest {
+ FullAuthenticationRequestData authenticationData = 1;
}
-message PullBackupKeyResponse {
- bytes encryptedBackupKey = 1;
+message RecoverBackupKeyResponse {
+ oneof data {
+ FullAuthenticationResponseData authenticationResponseData = 1;
+ BackupKeyEntropy backupKeyEntropy = 2;
+ string backupID = 4;
+ }
}
-// PullCompaction
+// PullBackup
-message PullCompactionRequest {
- string userId = 1;
- bytes message = 2;
+message PullBackupRequest {
+ SimpleAuthenticationRequestData authenticationData = 1;
}
-message PullCompactionResponse {
+message PullBackupResponse {
oneof data {
bytes compactionChunk = 1;
bytes logChunk = 2;

File Metadata

Mime Type
text/plain
Expires
Thu, Jan 9, 10:37 PM (11 h, 59 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2840244
Default Alt Text
D3076.diff (843 KB)

Event Timeline