diff --git a/.github/workflows/identity_tests.yml b/.github/workflows/identity_tests.yml
--- a/.github/workflows/identity_tests.yml
+++ b/.github/workflows/identity_tests.yml
@@ -5,7 +5,7 @@
branches: [master]
paths:
- 'services/identity/**'
- - 'shared/protos/identity.proto'
+ - 'shared/protos/identity_client.proto'
- 'flake.*'
- 'nix/**'
diff --git a/keyserver/addons/rust-node-addon/build.rs b/keyserver/addons/rust-node-addon/build.rs
--- a/keyserver/addons/rust-node-addon/build.rs
+++ b/keyserver/addons/rust-node-addon/build.rs
@@ -5,10 +5,7 @@
tonic_build::configure()
.build_server(false)
.compile(
- &[
- "../../../shared/protos/identity_client.proto",
- "../../../shared/protos/identity.proto",
- ],
+ &["../../../shared/protos/identity_client.proto"],
&["../../../shared/protos"],
)
.unwrap_or_else(|e| panic!("Failed to compile protos {:?}", e));
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/compare_users.rs b/keyserver/addons/rust-node-addon/src/identity_client/compare_users.rs
deleted file mode 100644
--- a/keyserver/addons/rust-node-addon/src/identity_client/compare_users.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use super::*;
-
-#[napi]
-#[instrument(skip_all)]
-async fn compare_users(
- users: Vec<String>,
-) -> Result<HashMap<String, Vec<String>>> {
- let channel = get_identity_service_channel().await?;
- let token: MetadataValue<_> = IDENTITY_SERVICE_CONFIG
- .identity_auth_token
- .parse()
- .map_err(|_| Error::from_status(Status::GenericFailure))?;
- let mut identity_client = IdentityKeyserverServiceClient::with_interceptor(
- channel,
- |mut req: Request<()>| {
- req.metadata_mut().insert("authorization", token.clone());
- Ok(req)
- },
- );
- let request = Request::new(CompareUsersRequest { users: users });
-
- match identity_client.compare_users(request).await {
- Ok(tonic_response) => {
- let compare_users_response = tonic_response.into_inner();
- let mut compare_result = HashMap::new();
- compare_result.insert(
- "usersMissingFromKeyserver".to_string(),
- compare_users_response.users_missing_from_keyserver,
- );
- compare_result.insert(
- "usersMissingFromIdentity".to_string(),
- compare_users_response.users_missing_from_identity,
- );
- Ok(compare_result)
- }
- Err(e) => Err(Error::new(Status::GenericFailure, e.to_string())),
- }
-}
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/delete_user.rs b/keyserver/addons/rust-node-addon/src/identity_client/delete_user.rs
deleted file mode 100644
--- a/keyserver/addons/rust-node-addon/src/identity_client/delete_user.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use super::*;
-
-#[napi]
-#[instrument(skip_all)]
-pub async fn delete_user(user_id: String) -> Result<()> {
- let channel = get_identity_service_channel().await?;
- let token: MetadataValue<_> = IDENTITY_SERVICE_CONFIG
- .identity_auth_token
- .parse()
- .map_err(|_| Error::from_status(Status::GenericFailure))?;
- let mut identity_client = IdentityKeyserverServiceClient::with_interceptor(
- channel,
- |mut req: Request<()>| {
- req.metadata_mut().insert("authorization", token.clone());
- Ok(req)
- },
- );
-
- let request = Request::new(DeleteUserRequest {
- user_id: user_id.clone(),
- });
- identity_client
- .delete_user(request)
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
-
- Ok(())
-}
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/login_user.rs b/keyserver/addons/rust-node-addon/src/identity_client/login_user.rs
deleted file mode 100644
--- a/keyserver/addons/rust-node-addon/src/identity_client/login_user.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use super::*;
-
-#[napi]
-#[instrument(skip_all)]
-async fn login_user_wallet(
- siwe_message: String,
- siwe_signature: String,
- signed_identity_keys_blob: SignedIdentityKeysBlob,
- social_proof: Option<String>,
-) -> Result<bool> {
- // Set up the gRPC client that will be used to talk to the Identity service
- let channel = get_identity_service_channel().await?;
- let token: MetadataValue<_> = IDENTITY_SERVICE_CONFIG
- .identity_auth_token
- .parse()
- .map_err(|_| Error::from_status(Status::GenericFailure))?;
- let mut identity_client = IdentityClientServiceClient::with_interceptor(
- channel,
- |mut req: Request<()>| {
- req.metadata_mut().insert("authorization", token.clone());
- Ok(req)
- },
- );
-
- // Create wallet login request and send it to the Identity service
- let device_key_upload = DeviceKeyUpload {
- device_key_info: Some(IdentityKeyInfo {
- payload: signed_identity_keys_blob.payload,
- payload_signature: signed_identity_keys_blob.signature,
- social_proof: social_proof,
- }),
- identity_upload: Some(identity_client::PreKey {
- pre_key: String::new(),
- pre_key_signature: String::new(),
- }),
- notif_upload: Some(identity_client::PreKey {
- pre_key: String::new(),
- pre_key_signature: String::new(),
- }),
- onetime_identity_prekeys: Vec::new(),
- onetime_notif_prekeys: Vec::new(),
- };
- let login_request = Request::new(WalletLoginRequest {
- siwe_message,
- siwe_signature,
- device_key_upload: Some(device_key_upload),
- });
-
- identity_client
- .login_wallet_user(login_request)
- .await
- .map_err(|_| Error::from_status(Status::GenericFailure))?
- .into_inner();
-
- Ok(true)
-}
-
-#[napi]
-#[instrument(skip_all)]
-async fn login_user_pake(
- user_id: String,
- signing_public_key: String,
- password: String,
- session_initialization_info: HashMap<String, String>,
-) -> Result<String> {
- let channel = get_identity_service_channel().await?;
- let token: MetadataValue<_> = IDENTITY_SERVICE_CONFIG
- .identity_auth_token
- .parse()
- .map_err(|_| Error::from_status(Status::GenericFailure))?;
- let mut identity_client = IdentityKeyserverServiceClient::with_interceptor(
- channel,
- |mut req: Request<()>| {
- req.metadata_mut().insert("authorization", token.clone());
- Ok(req)
- },
- );
-
- // Create a LoginRequest channel and use ReceiverStream to turn the
- // MPSC receiver into a Stream for outbound messages
- let (tx, rx) = mpsc::channel(1);
- let stream = ReceiverStream::new(rx);
- let request = Request::new(stream);
-
- // `response` is the Stream for inbound messages
- let mut response = identity_client
- .login_user(request)
- .await
- .map_err(|_| Error::from_status(Status::GenericFailure))?
- .into_inner();
-
- // Start PAKE login on client and send initial login request to Identity
- // service
- let mut client_rng = OsRng;
- let client_login_start_result = pake_login_start(&mut client_rng, &password)?;
- let pake_credential_request =
- client_login_start_result.message.serialize().map_err(|e| {
- error!("Could not serialize credential request: {}", e);
- Error::new(Status::GenericFailure, e.to_string())
- })?;
- let login_request = LoginRequest {
- data: Some(PakeLoginRequest(PakeLoginRequestStruct {
- data: Some(PakeCredentialRequestAndUserId(
- PakeCredentialRequestAndUserIdStruct {
- user_id,
- signing_public_key,
- pake_credential_request,
- session_initialization_info: Some(SessionInitializationInfo {
- info: session_initialization_info,
- }),
- },
- )),
- })),
- };
-
- send_to_mpsc(tx.clone(), login_request).await?;
-
- // Handle responses from Identity service sequentially, making sure we get
- // messages in the correct order
-
- // Finish PAKE login; send final login request to Identity service
- let message = response.message().await.map_err(|e| {
- error!("Received an error from inbound message stream: {}", e);
- match e.code() {
- Code::NotFound => {
- Error::new(Status::InvalidArg, "user not found".to_string())
- }
- _ => Error::new(Status::GenericFailure, e.to_string()),
- }
- })?;
- handle_login_credential_response(
- message,
- client_login_start_result.state,
- tx,
- )
- .await?;
-
- // Return access token
- let message = response.message().await.map_err(|e| {
- error!("Received an error from inbound message stream: {}", e);
- Error::from_status(Status::GenericFailure)
- })?;
- handle_login_token_response(message)
-}
-
-async fn handle_login_credential_response(
- message: Option<LoginResponse>,
- client_login: ClientLogin<Cipher>,
- tx: mpsc::Sender<LoginRequest>,
-) -> Result<(), Status> {
- if let Some(LoginResponse {
- data:
- Some(LoginPakeLoginResponse(PakeLoginResponseStruct {
- data: Some(PakeCredentialResponse(credential_response_bytes)),
- })),
- }) = message
- {
- let credential_finalization_bytes =
- pake_login_finish(&credential_response_bytes, client_login)?
- .serialize()
- .map_err(|e| {
- error!("Could not serialize credential request: {}", e);
- Error::from_status(Status::GenericFailure)
- })?;
- let login_request = LoginRequest {
- data: Some(PakeLoginRequest(PakeLoginRequestStruct {
- data: Some(LoginPakeCredentialFinalization(
- credential_finalization_bytes,
- )),
- })),
- };
- send_to_mpsc(tx, login_request).await
- } else {
- Err(handle_unexpected_response(message))
- }
-}
-
-fn handle_login_token_response(
- message: Option<LoginResponse>,
-) -> Result<String, Status> {
- if let Some(LoginResponse {
- data:
- Some(LoginPakeLoginResponse(PakeLoginResponseStruct {
- data: Some(AccessToken(access_token)),
- })),
- }) = message
- {
- Ok(access_token)
- } else {
- Err(handle_unexpected_response(message))
- }
-}
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/mod.rs b/keyserver/addons/rust-node-addon/src/identity_client/mod.rs
--- a/keyserver/addons/rust-node-addon/src/identity_client/mod.rs
+++ b/keyserver/addons/rust-node-addon/src/identity_client/mod.rs
@@ -1,48 +1,19 @@
-pub mod compare_users;
-pub mod delete_user;
-pub mod login_user;
pub mod register_user;
-pub mod identity {
- tonic::include_proto!("identity.keyserver");
-}
pub mod identity_client {
tonic::include_proto!("identity.client");
}
-pub mod update_user;
-use comm_opaque::Cipher;
-use identity::identity_keyserver_service_client::IdentityKeyserverServiceClient;
-use identity::{
- login_request::Data::PakeLoginRequest,
- login_response::Data::PakeLoginResponse as LoginPakeLoginResponse,
- pake_login_request::Data::PakeCredentialFinalization as LoginPakeCredentialFinalization,
- pake_login_request::Data::PakeCredentialRequestAndUserId,
- pake_login_response::Data::AccessToken,
- pake_login_response::Data::PakeCredentialResponse, CompareUsersRequest,
- DeleteUserRequest, LoginRequest, LoginResponse,
- PakeCredentialRequestAndUserId as PakeCredentialRequestAndUserIdStruct,
- PakeLoginRequest as PakeLoginRequestStruct,
- PakeLoginResponse as PakeLoginResponseStruct, SessionInitializationInfo,
-};
use identity_client::identity_client_service_client::IdentityClientServiceClient;
use identity_client::{
DeviceKeyUpload, IdentityKeyInfo, RegistrationFinishRequest,
- RegistrationStartRequest, WalletLoginRequest,
+ RegistrationStartRequest,
};
use lazy_static::lazy_static;
use napi::bindgen_prelude::*;
-use opaque_ke::{
- ClientLogin, ClientLoginFinishParameters, ClientLoginStartParameters,
- ClientLoginStartResult, CredentialFinalization, CredentialResponse,
-};
-use rand::{rngs::OsRng, CryptoRng, Rng};
use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
use std::env::var;
-use tokio::sync::mpsc;
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::{metadata::MetadataValue, transport::Channel, Code, Request};
-use tracing::{error, instrument};
+use tonic::{metadata::MetadataValue, transport::Channel, Request};
+use tracing::instrument;
lazy_static! {
static ref IDENTITY_SERVICE_CONFIG: IdentityServiceConfig = {
@@ -71,55 +42,6 @@
}
}
-fn handle_unexpected_response<T: std::fmt::Debug>(message: Option<T>) -> Error {
- error!("Received an unexpected message: {:?}", message);
- Error::from_status(Status::GenericFailure)
-}
-
-async fn send_to_mpsc<T>(tx: mpsc::Sender<T>, request: T) -> Result<()> {
- if let Err(e) = tx.send(request).await {
- error!("Response was dropped: {}", e);
- return Err(Error::from_status(Status::GenericFailure));
- }
- Ok(())
-}
-
-fn pake_login_start(
- rng: &mut (impl Rng + CryptoRng),
- password: &str,
-) -> Result<ClientLoginStartResult<Cipher>> {
- ClientLogin::<Cipher>::start(
- rng,
- password.as_bytes(),
- ClientLoginStartParameters::default(),
- )
- .map_err(|e| {
- error!("Failed to start PAKE login: {}", e);
- Error::from_status(Status::GenericFailure)
- })
-}
-
-fn pake_login_finish(
- credential_response_bytes: &[u8],
- client_login: ClientLogin<Cipher>,
-) -> Result<CredentialFinalization<Cipher>> {
- client_login
- .finish(
- CredentialResponse::deserialize(credential_response_bytes).map_err(
- |e| {
- error!("Could not deserialize credential response bytes: {}", e);
- Error::from_status(Status::GenericFailure)
- },
- )?,
- ClientLoginFinishParameters::default(),
- )
- .map_err(|e| {
- error!("Failed to finish PAKE login: {}", e);
- Error::from_status(Status::GenericFailure)
- })
- .map(|res| res.message)
-}
-
async fn get_identity_service_channel() -> Result<Channel> {
Channel::from_static(&IDENTITY_SERVICE_CONFIG.identity_socket_addr)
.connect()
diff --git a/keyserver/addons/rust-node-addon/src/identity_client/update_user.rs b/keyserver/addons/rust-node-addon/src/identity_client/update_user.rs
deleted file mode 100644
--- a/keyserver/addons/rust-node-addon/src/identity_client/update_user.rs
+++ /dev/null
@@ -1,311 +0,0 @@
-use crate::identity_client::identity as proto;
-use crate::identity_client::identity::pake_login_response::Data::AccessToken;
-use crate::identity_client::identity::{
- update_user_request, update_user_response, UpdateUserRequest,
- UpdateUserResponse,
-};
-use comm_opaque::Cipher;
-use napi::bindgen_prelude::*;
-use opaque_ke::{
- ClientLogin, ClientLoginFinishParameters, ClientLoginStartParameters,
- ClientLoginStartResult, ClientRegistration,
- ClientRegistrationFinishParameters, CredentialFinalization,
- CredentialResponse, RegistrationUpload,
-};
-use proto::identity_keyserver_service_client::IdentityKeyserverServiceClient;
-use rand::{rngs::OsRng, CryptoRng, Rng};
-use tokio::sync::mpsc;
-use tokio_stream::wrappers::ReceiverStream;
-use tonic;
-use tonic::metadata::MetadataValue;
-use tracing::{error, instrument};
-
-use super::{get_identity_service_channel, IDENTITY_SERVICE_CONFIG};
-
-#[napi]
-#[instrument(skip_all)]
-pub async fn update_user(user_id: String, password: String) -> Result<String> {
- let channel = get_identity_service_channel().await?;
- let token: MetadataValue<_> = IDENTITY_SERVICE_CONFIG
- .identity_auth_token
- .parse()
- .map_err(|_| Error::from_status(Status::GenericFailure))?;
- let mut identity_client = IdentityKeyserverServiceClient::with_interceptor(
- channel,
- |mut req: tonic::Request<()>| {
- req.metadata_mut().insert("authorization", token.clone());
- Ok(req)
- },
- );
-
- // Create a RegistrationRequest channel and use ReceiverStream to turn the
- // MPSC receiver into a Stream for outbound messages
- let (tx, rx) = mpsc::channel(1);
- let stream = ReceiverStream::new(rx);
- let request = tonic::Request::new(stream);
-
- // `response` is the Stream for inbound messages
- let mut response = identity_client
- .update_user(request)
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?
- .into_inner();
-
- // Start PAKE registration on client and send initial registration request
- // to Identity service
- let mut client_rng = OsRng;
- let (registration_request, client_registration) =
- pake_registration_start(&mut client_rng, user_id, &password)?;
- send_to_mpsc(&tx, registration_request).await?;
-
- // Handle responses from Identity service sequentially, making sure we get
- // messages in the correct order
-
- // Finish PAKE registration and begin PAKE login; send the final
- // registration request and initial login request together to reduce the
- // number of trips
- let message = response
- .message()
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
- let registration_response = get_registration_response(message)?;
- let client_login = handle_registration_response(
- ®istration_response,
- &mut client_rng,
- client_registration,
- &password,
- &tx,
- )
- .await?;
-
- // Finish PAKE login; send final login request to Identity service
- let message = response
- .message()
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
- let credential_response = get_login_credential_response(message)?;
- handle_login_credential_response(&credential_response, client_login, &tx)
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
-
- // Return access token
- let message = response
- .message()
- .await
- .map_err(|e| Error::new(Status::GenericFailure, e.to_string()))?;
- get_login_token_response(message)
-}
-
-fn handle_unexpected_response<T: std::fmt::Debug>(message: Option<T>) -> Error {
- error!("Received an unexpected message: {:?}", message);
- Error::from_status(Status::GenericFailure)
-}
-
-async fn send_to_mpsc<T>(tx: &mpsc::Sender<T>, request: T) -> Result<()> {
- if let Err(e) = tx.send(request).await {
- error!("Response was dropped: {}", e);
- return Err(Error::from_status(Status::GenericFailure));
- }
- Ok(())
-}
-
-fn pake_login_start(
- rng: &mut (impl Rng + CryptoRng),
- password: &str,
-) -> Result<ClientLoginStartResult<Cipher>> {
- ClientLogin::<Cipher>::start(
- rng,
- password.as_bytes(),
- ClientLoginStartParameters::default(),
- )
- .map_err(|e| {
- error!("Failed to start PAKE login: {}", e);
- Error::from_status(Status::GenericFailure)
- })
-}
-
-fn pake_login_finish(
- credential_response_bytes: &[u8],
- client_login: ClientLogin<Cipher>,
-) -> Result<CredentialFinalization<Cipher>> {
- client_login
- .finish(
- CredentialResponse::deserialize(credential_response_bytes).map_err(
- |e| {
- error!("Could not deserialize credential response bytes: {}", e);
- Error::from_status(Status::GenericFailure)
- },
- )?,
- ClientLoginFinishParameters::default(),
- )
- .map_err(|e| {
- error!("Failed to finish PAKE login: {}", e);
- Error::from_status(Status::GenericFailure)
- })
- .map(|res| res.message)
-}
-
-fn pake_registration_start(
- rng: &mut (impl Rng + CryptoRng),
- user_id: String,
- password: &str,
-) -> Result<(UpdateUserRequest, ClientRegistration<Cipher>)> {
- let client_registration_start_result =
- ClientRegistration::<Cipher>::start(rng, password.as_bytes()).map_err(
- |e| {
- error!("Failed to start PAKE registration: {}", e);
- Error::from_status(Status::GenericFailure)
- },
- )?;
- let pake_registration_request =
- client_registration_start_result.message.serialize();
- Ok((
- UpdateUserRequest {
- data: Some(update_user_request::Data::Request(
- crate::identity_client::identity::PakeRegistrationRequestAndUserId {
- user_id,
- pake_registration_request,
- username: "placeholder-username".to_string(),
- signing_public_key: "placeholder-signing-public-key".to_string(),
- session_initialization_info: None,
- },
- )),
- },
- client_registration_start_result.state,
- ))
-}
-
-async fn handle_registration_response(
- registration_reponse_payload: &[u8],
- client_rng: &mut (impl Rng + CryptoRng),
- client_registration: ClientRegistration<Cipher>,
- password: &str,
- tx: &mpsc::Sender<UpdateUserRequest>,
-) -> Result<ClientLogin<Cipher>> {
- let pake_registration_upload = pake_registration_finish(
- client_rng,
- ®istration_reponse_payload,
- client_registration,
- )?
- .serialize();
- let client_login_start_result = pake_login_start(client_rng, password)?;
- let pake_login_request =
- client_login_start_result.message.serialize().map_err(|e| {
- error!("Could not serialize credential request: {}", e);
- Error::from_status(Status::GenericFailure)
- })?;
-
- // `registration_request` is a gRPC message containing serialized bytes to
- // complete PAKE registration and begin PAKE login
- let inner_message: update_user_request::Data =
- update_user_request::Data::PakeRegistrationUploadAndCredentialRequest(
- crate::identity_client::identity::PakeRegistrationUploadAndCredentialRequest {
- pake_registration_upload,
- pake_credential_request: pake_login_request,
- },
- );
- let registration_request = UpdateUserRequest {
- data: Some(inner_message),
- };
- send_to_mpsc(tx, registration_request).await?;
- Ok(client_login_start_result.state)
-}
-
-fn get_registration_response(
- message: Option<UpdateUserResponse>,
-) -> Result<Vec<u8>> {
- match message {
- Some(UpdateUserResponse {
- data:
- Some(update_user_response::Data::PakeRegistrationResponse(
- registration_response_bytes,
- )),
- ..
- }) => Ok(registration_response_bytes),
- _ => {
- error!("Received an unexpected message: {:?}", message);
- Err(Error::from_status(Status::GenericFailure))
- }
- }
-}
-
-async fn handle_login_credential_response(
- registration_response_payload: &[u8],
- client_login: ClientLogin<Cipher>,
- tx: &mpsc::Sender<UpdateUserRequest>,
-) -> Result<()> {
- let pake_login_finish_result =
- pake_login_finish(®istration_response_payload, client_login)?;
- let login_finish_message =
- pake_login_finish_result.serialize().map_err(|e| {
- error!("Could not serialize credential request: {}", e);
- Error::from_status(Status::GenericFailure)
- })?;
- let registration_request = UpdateUserRequest {
- data: Some(
- proto::update_user_request::Data::PakeLoginFinalizationMessage(
- login_finish_message,
- ),
- ),
- };
- send_to_mpsc(tx, registration_request).await
-}
-
-fn get_login_credential_response(
- message: Option<UpdateUserResponse>,
-) -> Result<Vec<u8>> {
- match message {
- Some(UpdateUserResponse {
- data:
- Some(update_user_response::Data::PakeLoginResponse(
- proto::PakeLoginResponse {
- data:
- Some(proto::pake_login_response::Data::PakeCredentialResponse(
- bytes,
- )),
- },
- )),
- }) => Ok(bytes),
- _ => Err(handle_unexpected_response(message)),
- }
-}
-
-fn get_login_token_response(
- message: Option<UpdateUserResponse>,
-) -> Result<String> {
- match message {
- Some(UpdateUserResponse {
- data:
- Some(update_user_response::Data::PakeLoginResponse(
- proto::PakeLoginResponse {
- data: Some(AccessToken(access_token)),
- },
- )),
- }) => Ok(access_token),
- _ => Err(handle_unexpected_response(message)),
- }
-}
-
-fn pake_registration_finish(
- rng: &mut (impl Rng + CryptoRng),
- registration_response_bytes: &[u8],
- client_registration: ClientRegistration<Cipher>,
-) -> Result<RegistrationUpload<Cipher>> {
- let register_payload =
- opaque_ke::RegistrationResponse::deserialize(registration_response_bytes)
- .map_err(|e| {
- error!("Could not deserialize registration response bytes: {}", e);
- Error::from_status(Status::GenericFailure)
- })?;
- client_registration
- .finish(
- rng,
- register_payload,
- ClientRegistrationFinishParameters::default(),
- )
- .map_err(|e| {
- error!("Failed to finish PAKE registration: {}", e);
- Error::from_status(Status::GenericFailure)
- })
- .map(|res| res.message)
-}
diff --git a/services/identity/Dockerfile b/services/identity/Dockerfile
--- a/services/identity/Dockerfile
+++ b/services/identity/Dockerfile
@@ -28,7 +28,6 @@
RUN rm src/*.rs
COPY services/identity .
-COPY shared/protos/identity.proto ../../shared/protos/
COPY shared/protos/identity_client.proto ../../shared/protos/
# Remove the previously-built binary so that only the application itself is
diff --git a/services/identity/build.rs b/services/identity/build.rs
--- a/services/identity/build.rs
+++ b/services/identity/build.rs
@@ -3,10 +3,7 @@
.build_server(true)
.build_client(false)
.compile(
- &[
- "../../shared/protos/identity.proto",
- "../../shared/protos/identity_client.proto",
- ],
+ &["../../shared/protos/identity_client.proto"],
&["../../shared/protos/"],
)?;
Ok(())
diff --git a/services/identity/src/client_service.rs b/services/identity/src/client_service.rs
--- a/services/identity/src/client_service.rs
+++ b/services/identity/src/client_service.rs
@@ -17,15 +17,16 @@
VerifyUserAccessTokenRequest, VerifyUserAccessTokenResponse,
WalletLoginRequest, WalletLoginResponse,
},
- database::DatabaseClient,
+ database::{DatabaseClient, Error as DBError},
nonce::generate_nonce_data,
- service::handle_db_error,
};
+use aws_sdk_dynamodb::Error as DynamoDBError;
pub use client_proto::identity_client_service_server::{
IdentityClientService, IdentityClientServiceServer,
};
use rand::rngs::OsRng;
use tonic::Response;
+use tracing::error;
#[derive(derive_more::Constructor)]
pub struct ClientService {
@@ -151,3 +152,19 @@
unimplemented!();
}
}
+
+pub fn handle_db_error(db_error: DBError) -> tonic::Status {
+ match db_error {
+ DBError::AwsSdk(DynamoDBError::InternalServerError(_))
+ | DBError::AwsSdk(DynamoDBError::ProvisionedThroughputExceededException(
+ _,
+ ))
+ | DBError::AwsSdk(DynamoDBError::RequestLimitExceeded(_)) => {
+ tonic::Status::unavailable("please retry")
+ }
+ e => {
+ error!("Encountered an unexpected error: {}", e);
+ tonic::Status::failed_precondition("unexpected error")
+ }
+ }
+}
diff --git a/services/identity/src/main.rs b/services/identity/src/main.rs
--- a/services/identity/src/main.rs
+++ b/services/identity/src/main.rs
@@ -1,6 +1,5 @@
use clap::{Parser, Subcommand};
use database::DatabaseClient;
-use interceptor::check_auth;
use tonic::transport::Server;
use tracing_subscriber::FmtSubscriber;
@@ -11,14 +10,11 @@
mod interceptor;
mod keygen;
mod nonce;
-mod pake_grpc;
-mod service;
mod token;
use config::load_config;
use constants::{IDENTITY_SERVICE_SOCKET_ADDR, SECRETS_DIRECTORY};
use keygen::generate_and_persist_keypair;
-use service::{IdentityKeyserverServiceServer, MyIdentityService};
use tracing::info;
use client_service::{ClientService, IdentityClientServiceServer};
@@ -59,15 +55,11 @@
let addr = IDENTITY_SERVICE_SOCKET_ADDR.parse()?;
let aws_config = aws_config::from_env().region("us-east-2").load().await;
let database_client = DatabaseClient::new(&aws_config);
- let server = MyIdentityService::new(database_client.clone());
- let keyserver_service =
- IdentityKeyserverServiceServer::with_interceptor(server, check_auth);
let client_service =
IdentityClientServiceServer::new(ClientService::new(database_client));
info!("Listening to gRPC traffic on {}", addr);
Server::builder()
.accept_http1(true)
- .add_service(keyserver_service)
.add_service(tonic_web::enable(client_service))
.serve(addr)
.await?;
diff --git a/services/identity/src/pake_grpc.rs b/services/identity/src/pake_grpc.rs
deleted file mode 100644
--- a/services/identity/src/pake_grpc.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use comm_opaque::Cipher;
-use opaque_ke::CredentialFinalization;
-use opaque_ke::CredentialRequest;
-use opaque_ke::RegistrationRequest;
-use opaque_ke::RegistrationUpload;
-use opaque_ke::ServerLogin;
-use opaque_ke::ServerLoginFinishResult;
-use opaque_ke::ServerLoginStartParameters;
-use opaque_ke::ServerLoginStartResult;
-use opaque_ke::ServerRegistration;
-use opaque_ke::ServerRegistrationStartResult;
-use rand::CryptoRng;
-use rand::Rng;
-use tonic::Status;
-use tracing::error;
-
-use crate::config::CONFIG;
-
-/// This file is meant to expose the opaque_ke actions, but
-/// returning tonic::Status as the error type to reduce boilerplate
-/// around describing PAKE failures to grpc.
-
-pub fn server_registration_start(
- rng: &mut (impl Rng + CryptoRng),
- pake_registration_request: &Vec<u8>,
-) -> Result<ServerRegistrationStartResult<Cipher>, Status> {
- let registration_bytes = RegistrationRequest::deserialize(
- &pake_registration_request[..],
- )
- .map_err(|e| {
- error!("Unsuccessfully deserialized registration bytes: {}", e);
- Status::invalid_argument("Invalid Registration response")
- })?;
- ServerRegistration::<Cipher>::start(
- rng,
- registration_bytes,
- CONFIG.server_keypair.public(),
- )
- .map_err(|e| {
- error!("Unsuccessfully started PAKE server response: {}", e);
- Status::aborted("server error")
- })
-}
-
-pub fn server_registration_finish(
- server_registration: ServerRegistration<Cipher>,
- registration_upload_bytes: &Vec<u8>,
-) -> Result<ServerRegistration<Cipher>, Status> {
- let upload_payload = RegistrationUpload::deserialize(
- registration_upload_bytes,
- )
- .map_err(|e| {
- error!("Failed to deserialize registration upload bytes: {}", e);
- Status::invalid_argument("invalid registration")
- })?;
- server_registration.finish(upload_payload).map_err(|e| {
- error!(
- "Encountered a PAKE protocol error when finishing registration: {}",
- e
- );
- Status::aborted("server error")
- })
-}
-
-pub fn server_login_start(
- rng: &mut (impl Rng + CryptoRng),
- server_registration: ServerRegistration<Cipher>,
- pake_credential_request: &[u8],
-) -> Result<ServerLoginStartResult<Cipher>, Status> {
- let credential_request =
- CredentialRequest::deserialize(pake_credential_request).map_err(|e| {
- error!("Failed to deserialize credential request: {}", e);
- Status::invalid_argument("invalid message")
- })?;
- ServerLogin::start(
- rng,
- server_registration,
- CONFIG.server_keypair.private(),
- credential_request,
- ServerLoginStartParameters::default(),
- )
- .map_err(|e| {
- error!(
- "Encountered a PAKE protocol error when starting login: {}",
- e
- );
- Status::aborted("server error")
- })
-}
-pub fn server_login_finish(
- server_login: ServerLogin<Cipher>,
- pake_credential_finalization: &Vec<u8>,
-) -> Result<ServerLoginFinishResult<Cipher>, Status> {
- let finalization_payload =
- CredentialFinalization::deserialize(&pake_credential_finalization[..])
- .map_err(|e| {
- error!("Failed to deserialize credential finalization bytes: {}", e);
- Status::invalid_argument("Could not deserialize login credentials")
- })?;
- server_login.finish(finalization_payload).map_err(|e| {
- error!(
- "Encountered a PAKE protocol error when finishing login: {}",
- e
- );
- Status::aborted("server error")
- })
-}
diff --git a/services/identity/src/service.rs b/services/identity/src/service.rs
deleted file mode 100644
--- a/services/identity/src/service.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-use aws_sdk_dynamodb::output::GetItemOutput;
-use aws_sdk_dynamodb::Error as DynamoDBError;
-use chrono::Utc;
-use comm_opaque::Cipher;
-use constant_time_eq::constant_time_eq;
-use futures_core::Stream;
-use opaque_ke::{ServerLogin, ServerRegistration};
-use rand::rngs::OsRng;
-use rand::{CryptoRng, Rng};
-use siwe::Message;
-use std::collections::{HashMap, HashSet};
-use std::pin::Pin;
-use tokio::sync::mpsc;
-use tokio_stream::{wrappers::ReceiverStream, StreamExt};
-use tonic::{Request, Response, Status};
-use tracing::{error, info, instrument};
-
-use crate::constants::MPSC_CHANNEL_BUFFER_CAPACITY;
-use crate::database::{DatabaseClient, Error as DBError};
-use crate::nonce::generate_nonce_data;
-use crate::pake_grpc;
-use crate::token::{AccessTokenData, AuthType};
-
-pub use proto::identity_keyserver_service_server::IdentityKeyserverServiceServer;
-use proto::{
- get_user_id_request::AuthType as ProtoAuthType,
- identity_keyserver_service_server::IdentityKeyserverService,
- login_request::Data::PakeLoginRequest,
- login_request::Data::WalletLoginRequest,
- login_response::Data::PakeLoginResponse,
- login_response::Data::WalletLoginResponse,
- pake_login_request::Data::PakeCredentialFinalization,
- pake_login_request::Data::PakeCredentialRequestAndUserId,
- pake_login_response::Data::AccessToken,
- pake_login_response::Data::PakeCredentialResponse,
- registration_request::Data::PakeCredentialFinalization as PakeRegistrationCredentialFinalization,
- registration_request::Data::PakeRegistrationRequestAndUserId,
- registration_request::Data::PakeRegistrationUploadAndCredentialRequest,
- registration_response::Data::PakeLoginResponse as PakeRegistrationLoginResponse,
- registration_response::Data::PakeRegistrationResponse, CompareUsersRequest,
- CompareUsersResponse, DeleteUserRequest, DeleteUserResponse,
- GenerateNonceRequest, GenerateNonceResponse,
- GetSessionInitializationInfoRequest, GetSessionInitializationInfoResponse,
- GetUserIdRequest, GetUserIdResponse, LoginRequest, LoginResponse,
- PakeLoginRequest as PakeLoginRequestStruct,
- PakeLoginResponse as PakeLoginResponseStruct, RegistrationRequest,
- RegistrationResponse, SessionInitializationInfo, UpdateUserRequest,
- UpdateUserResponse, VerifyUserTokenRequest, VerifyUserTokenResponse,
- WalletLoginRequest as WalletLoginRequestStruct,
- WalletLoginResponse as WalletLoginResponseStruct,
-};
-
-mod proto {
- tonic::include_proto!("identity.keyserver");
-}
-
-mod login;
-mod registration;
-mod update;
-
-#[derive(Debug)]
-enum PakeWorkflow {
- Registration,
- Login,
-}
-
-#[derive(derive_more::Constructor)]
-pub struct MyIdentityService {
- client: DatabaseClient,
-}
-
-#[tonic::async_trait]
-impl IdentityKeyserverService for MyIdentityService {
- type RegisterUserStream = Pin<
- Box<
- dyn Stream<Item = Result<RegistrationResponse, Status>> + Send + 'static,
- >,
- >;
-
- #[instrument(skip(self))]
- async fn register_user(
- &self,
- request: Request<tonic::Streaming<RegistrationRequest>>,
- ) -> Result<Response<Self::RegisterUserStream>, Status> {
- let mut in_stream = request.into_inner();
- let (tx, rx) = mpsc::channel(MPSC_CHANNEL_BUFFER_CAPACITY);
- let client = self.client.clone();
-
- tokio::spawn(async move {
- let first_message = in_stream.next().await;
- let mut registration_state = registration::handle_registration_request(
- first_message,
- &client,
- tx.clone(),
- )
- .await?;
- // ServerRegistration in opaque-ke v1.2 doesn't implement Clone, so we
- // have to take the value out of registration_state, replacing it with None
- let pake_state =
- if let Some(pake_state) = registration_state.pake_state.take() {
- pake_state
- } else {
- error!("registration_state is missing opaque-ke ServerRegistration");
- return Err(Status::failed_precondition("internal error"));
- };
- let second_message = in_stream.next().await;
- let server_login =
- registration::handle_registration_upload_and_credential_request(
- second_message,
- tx.clone(),
- &client,
- ®istration_state,
- pake_state,
- )
- .await?;
- let third_message = in_stream.next().await;
- registration::handle_credential_finalization(
- third_message,
- tx,
- &client,
- ®istration_state,
- server_login,
- )
- .await?;
- Ok(())
- });
-
- let out_stream = ReceiverStream::new(rx);
- Ok(Response::new(
- Box::pin(out_stream) as Self::RegisterUserStream
- ))
- }
-
- type LoginUserStream =
- Pin<Box<dyn Stream<Item = Result<LoginResponse, Status>> + Send + 'static>>;
-
- #[instrument(skip(self))]
- async fn login_user(
- &self,
- request: Request<tonic::Streaming<LoginRequest>>,
- ) -> Result<Response<Self::LoginUserStream>, Status> {
- let mut in_stream = request.into_inner();
- let (tx, rx) = mpsc::channel(MPSC_CHANNEL_BUFFER_CAPACITY);
- let client = self.client.clone();
-
- tokio::spawn(async move {
- let first_message = in_stream.next().await;
- let login_state =
- login::handle_login_request(first_message, tx.clone(), &client).await?;
-
- // login_state will be None if user is logging in with a wallet
- if let Some(state) = login_state {
- let second_message = in_stream.next().await;
- login::handle_credential_finalization(
- second_message,
- tx,
- &client,
- state,
- )
- .await?;
- }
- Ok::<(), Status>(())
- });
-
- let out_stream = ReceiverStream::new(rx);
- Ok(Response::new(Box::pin(out_stream) as Self::LoginUserStream))
- }
-
- #[instrument(skip(self))]
- async fn verify_user_token(
- &self,
- request: Request<VerifyUserTokenRequest>,
- ) -> Result<Response<VerifyUserTokenResponse>, Status> {
- info!("Received VerifyUserToken request: {:?}", request);
- let message = request.into_inner();
- let token_valid = match self
- .client
- .get_access_token_data(message.user_id, message.signing_public_key)
- .await
- {
- Ok(Some(access_token_data)) => constant_time_eq(
- access_token_data.access_token.as_bytes(),
- message.access_token.as_bytes(),
- ),
- Ok(None) => false,
- Err(e) => return Err(handle_db_error(e)),
- };
- let response = Response::new(VerifyUserTokenResponse { token_valid });
- info!("Sending VerifyUserToken response: {:?}", response);
- Ok(response)
- }
-
- #[instrument(skip(self))]
- async fn get_user_id(
- &self,
- request: Request<GetUserIdRequest>,
- ) -> Result<Response<GetUserIdResponse>, Status> {
- let message = request.into_inner();
- let auth_type = match ProtoAuthType::from_i32(message.auth_type) {
- Some(ProtoAuthType::Password) => AuthType::Password,
- Some(ProtoAuthType::Wallet) => AuthType::Wallet,
- None => {
- error!(
- "Unable to parse AuthType from message: {}",
- message.auth_type
- );
- return Err(Status::invalid_argument("invalid message"));
- }
- };
- let user_id = match self
- .client
- .get_user_id_from_user_info(message.user_info, auth_type)
- .await
- {
- Ok(Some(user_id)) => user_id,
- Ok(None) => return Err(Status::not_found("no user ID found")),
- Err(e) => return Err(handle_db_error(e)),
- };
- let response = Response::new(GetUserIdResponse { user_id });
- Ok(response)
- }
-
- #[instrument(skip(self))]
- async fn delete_user(
- &self,
- request: tonic::Request<DeleteUserRequest>,
- ) -> Result<tonic::Response<DeleteUserResponse>, tonic::Status> {
- let message = request.into_inner();
- match self.client.delete_user(message.user_id).await {
- Ok(_) => Ok(Response::new(DeleteUserResponse {})),
- Err(e) => Err(handle_db_error(e)),
- }
- }
-
- #[instrument(skip(self))]
- async fn compare_users(
- &self,
- request: Request<CompareUsersRequest>,
- ) -> Result<Response<CompareUsersResponse>, Status> {
- let message = request.into_inner();
- let mut mysql_users_vec = message.users;
- let mut ddb_users_vec = match self.client.get_users().await {
- Ok(user_list) => user_list,
- Err(e) => return Err(handle_db_error(e)),
- };
- // We use HashSets here for faster lookups
- let mysql_users_set = HashSet::<String>::from_iter(mysql_users_vec.clone());
- let ddb_users_set = HashSet::<String>::from_iter(ddb_users_vec.clone());
-
- ddb_users_vec.retain(|user| !mysql_users_set.contains(user));
- mysql_users_vec.retain(|user| !ddb_users_set.contains(user));
- Ok(Response::new(CompareUsersResponse {
- users_missing_from_keyserver: ddb_users_vec,
- users_missing_from_identity: mysql_users_vec,
- }))
- }
-
- #[instrument(skip(self))]
- async fn generate_nonce(
- &self,
- _request: Request<GenerateNonceRequest>,
- ) -> Result<Response<GenerateNonceResponse>, Status> {
- let nonce_data = generate_nonce_data(&mut OsRng);
- match self
- .client
- .add_nonce_to_nonces_table(nonce_data.clone())
- .await
- {
- Ok(_) => Ok(Response::new(GenerateNonceResponse {
- nonce: nonce_data.nonce,
- })),
- Err(e) => Err(handle_db_error(e)),
- }
- }
-
- #[instrument(skip(self))]
- async fn get_session_initialization_info(
- &self,
- request: Request<GetSessionInitializationInfoRequest>,
- ) -> Result<Response<GetSessionInitializationInfoResponse>, Status> {
- let message = request.into_inner();
- match self
- .client
- .get_session_initialization_info(&message.user_id)
- .await
- {
- Ok(Some(session_initialization_info)) => {
- let mut devices = HashMap::new();
- for (device, info) in session_initialization_info {
- devices.insert(device, SessionInitializationInfo { info });
- }
- Ok(Response::new(GetSessionInitializationInfoResponse {
- devices,
- }))
- }
- Ok(None) => return Err(Status::not_found("user not found")),
- Err(e) => Err(handle_db_error(e)),
- }
- }
-
- #[instrument(skip(self))]
- async fn update_user(
- &self,
- request: Request<tonic::Streaming<UpdateUserRequest>>,
- ) -> Result<Response<Self::UpdateUserStream>, Status> {
- let (tx, rx) = mpsc::channel(MPSC_CHANNEL_BUFFER_CAPACITY);
- let db_client = self.client.clone();
-
- tokio::spawn(async move {
- update::handle_server_update_user_messages(
- request.into_inner(),
- db_client,
- tx,
- )
- .await;
- });
-
- let out_stream = ReceiverStream::new(rx);
-
- Ok(Response::new(Box::pin(out_stream) as Self::UpdateUserStream))
- }
-
- type UpdateUserStream = Pin<
- Box<dyn Stream<Item = Result<UpdateUserResponse, Status>> + Send + 'static>,
- >;
-}
-
-async fn put_token_helper(
- client: &DatabaseClient,
- auth_type: AuthType,
- user_id: &str,
- signing_public_key: &str,
- rng: &mut (impl Rng + CryptoRng),
-) -> Result<String, Status> {
- if user_id.is_empty() || signing_public_key.is_empty() {
- error!(
- "Incomplete data: user ID \"{}\", signing public key \"{}\"",
- user_id, signing_public_key
- );
- return Err(Status::aborted("user not found"));
- }
- let access_token_data = AccessTokenData::new(
- user_id.to_string(),
- signing_public_key.to_string(),
- auth_type,
- rng,
- );
- match client
- .put_access_token_data(access_token_data.clone())
- .await
- {
- Ok(_) => Ok(access_token_data.access_token),
- Err(e) => Err(handle_db_error(e)),
- }
-}
-
-fn parse_and_verify_siwe_message(
- user_id: &str,
- signing_public_key: &str,
- siwe_message: &str,
- siwe_signature: &str,
-) -> Result<(), Status> {
- if user_id.is_empty() || signing_public_key.is_empty() {
- error!(
- "Incomplete data: user ID {}, signing public key {}",
- user_id, signing_public_key
- );
- return Err(Status::aborted("user not found"));
- }
- let siwe_message: Message = match siwe_message.parse() {
- Ok(m) => m,
- Err(e) => {
- error!("Failed to parse SIWE message: {}", e);
- return Err(Status::invalid_argument("invalid message"));
- }
- };
-
- let decoded_signature = hex::decode(siwe_signature.trim_start_matches("0x"))
- .map_err(|e| {
- error!("Failed to decode SIWE signature: {}", e);
- Status::invalid_argument("invalid signature")
- })?;
-
- match siwe_message.verify(
- match decoded_signature.try_into() {
- Ok(s) => s,
- Err(e) => {
- error!("Conversion to SIWE signature failed: {:?}", e);
- return Err(Status::invalid_argument("invalid message"));
- }
- },
- None,
- None,
- Some(&Utc::now()),
- ) {
- Err(e) => {
- error!(
- "Signature verification failed for user {} with signing public key {}: {}",
- user_id, signing_public_key, e
- );
- Err(Status::unauthenticated("message not authenticated"))
- }
- Ok(_) => Ok(()),
- }
-}
-
-async fn wallet_login_helper(
- client: &DatabaseClient,
- wallet_login_request: WalletLoginRequestStruct,
- rng: &mut (impl Rng + CryptoRng),
-) -> Result<LoginResponse, Status> {
- parse_and_verify_siwe_message(
- &wallet_login_request.user_id,
- &wallet_login_request.signing_public_key,
- &wallet_login_request.siwe_message,
- &wallet_login_request.siwe_signature,
- )?;
- client
- .update_users_table(
- wallet_login_request.user_id.clone(),
- Some(wallet_login_request.signing_public_key.clone()),
- None,
- None,
- Some(
- &wallet_login_request
- .session_initialization_info
- .ok_or_else(|| Status::invalid_argument("Invalid message"))?
- .info,
- ),
- )
- .await
- .map_err(handle_db_error)?;
- Ok(LoginResponse {
- data: Some(WalletLoginResponse(WalletLoginResponseStruct {
- access_token: put_token_helper(
- client,
- AuthType::Wallet,
- &wallet_login_request.user_id,
- &wallet_login_request.signing_public_key,
- rng,
- )
- .await?,
- })),
- })
-}
-
-async fn pake_login_start(
- client: &DatabaseClient,
- user_id: &str,
- pake_credential_request: &[u8],
-) -> Result<LoginResponseAndPakeState, Status> {
- if user_id.is_empty() {
- error!("Incomplete data: user ID not provided");
- return Err(Status::aborted("user not found"));
- }
- let server_registration =
- match client.get_pake_registration(user_id.to_string()).await {
- Ok(Some(r)) => r,
- Ok(None) => {
- return Err(Status::not_found("user not found"));
- }
- Err(e) => return Err(handle_db_error(e)),
- };
- let server_login_start_result = pake_grpc::server_login_start(
- &mut OsRng,
- server_registration,
- pake_credential_request,
- )?;
- let credential_response =
- server_login_start_result.message.serialize().map_err(|e| {
- error!("Failed to serialize PAKE message: {}", e);
- Status::failed_precondition("internal error")
- })?;
- Ok(LoginResponseAndPakeState {
- response: PakeLoginResponseStruct {
- data: Some(PakeCredentialResponse(credential_response)),
- },
- pake_state: server_login_start_result.state,
- })
-}
-
-async fn pake_login_finish(
- user_id: &str,
- signing_public_key: &str,
- client: &DatabaseClient,
- server_login: ServerLogin<Cipher>,
- pake_credential_finalization: &Vec<u8>,
- rng: &mut (impl Rng + CryptoRng),
- pake_workflow: PakeWorkflow,
- session_initialization_info: &HashMap<String, String>,
-) -> Result<PakeLoginResponseStruct, Status> {
- if user_id.is_empty() || signing_public_key.is_empty() {
- error!(
- "Incomplete data: user ID {}, signing public key {}",
- user_id, signing_public_key
- );
- return Err(Status::aborted("user not found"));
- }
-
- pake_grpc::server_login_finish(server_login, pake_credential_finalization)?;
- if matches!(pake_workflow, PakeWorkflow::Login) {
- client
- .update_users_table(
- user_id.to_string(),
- Some(signing_public_key.to_string()),
- None,
- None,
- Some(session_initialization_info),
- )
- .await
- .map_err(handle_db_error)?;
- }
- Ok(PakeLoginResponseStruct {
- data: Some(AccessToken(
- put_token_helper(
- client,
- AuthType::Password,
- user_id,
- signing_public_key,
- rng,
- )
- .await?,
- )),
- })
-}
-
-async fn server_register_response(
- registration_request_bytes: &Vec<u8>,
-) -> Result<RegistrationResponseAndPakeState, Status> {
- let server_registration_start_result = pake_grpc::server_registration_start(
- &mut OsRng,
- registration_request_bytes,
- )?;
- Ok(RegistrationResponseAndPakeState {
- response: RegistrationResponse {
- data: Some(PakeRegistrationResponse(
- server_registration_start_result.message.serialize(),
- )),
- },
- pake_state: server_registration_start_result.state,
- })
-}
-
-async fn pake_registration_finish(
- user_id: &str,
- client: &DatabaseClient,
- registration_upload_bytes: &Vec<u8>,
- server_registration: ServerRegistration<Cipher>,
- username: &str,
- signing_public_key: &str,
- session_initialization_info: &HashMap<String, String>,
-) -> Result<(), Status> {
- if user_id.is_empty() {
- error!("Incomplete data: user ID not provided");
- return Err(Status::aborted("user not found"));
- }
- let server_registration_finish_result =
- pake_grpc::server_registration_finish(
- server_registration,
- registration_upload_bytes,
- )?;
-
- match client
- .add_user_to_users_table(
- user_id.to_string(),
- server_registration_finish_result,
- username.to_string(),
- signing_public_key.to_string(),
- session_initialization_info,
- )
- .await
- {
- Ok(_) => Ok(()),
- Err(e) => Err(handle_db_error(e)),
- }
-}
-
-pub fn handle_db_error(db_error: DBError) -> Status {
- match db_error {
- DBError::AwsSdk(DynamoDBError::InternalServerError(_))
- | DBError::AwsSdk(DynamoDBError::ProvisionedThroughputExceededException(
- _,
- ))
- | DBError::AwsSdk(DynamoDBError::RequestLimitExceeded(_)) => {
- Status::unavailable("please retry")
- }
- e => {
- error!("Encountered an unexpected error: {}", e);
- Status::failed_precondition("unexpected error")
- }
- }
-}
-
-struct RegistrationResponseAndPakeState {
- response: RegistrationResponse,
- pake_state: ServerRegistration<Cipher>,
-}
-
-struct LoginResponseAndPakeState {
- response: PakeLoginResponseStruct,
- pake_state: ServerLogin<Cipher>,
-}
-
-async fn send_to_client<T>(
- tx: &tokio::sync::mpsc::Sender<Result<T, Status>>,
- response: Result<T, Status>,
-) -> Result<(), Status> {
- let transport_result = match response {
- Ok(message) => tx.send(Ok(message)).await,
- Err(status) => {
- error!("{}", status.message());
- tx.send(Err(status)).await
- }
- };
-
- transport_result.map_err(|_| Status::internal("disconnection"))
-}
diff --git a/services/identity/src/service/login.rs b/services/identity/src/service/login.rs
deleted file mode 100644
--- a/services/identity/src/service/login.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use super::*;
-pub struct LoginState {
- user_id: String,
- signing_public_key: String,
- pake_state: ServerLogin<Cipher>,
- session_initialization_info: HashMap<String, String>,
-}
-pub async fn handle_login_request(
- message: Option<Result<LoginRequest, Status>>,
- tx: mpsc::Sender<Result<LoginResponse, Status>>,
- client: &DatabaseClient,
-) -> Result<Option<LoginState>, Status> {
- match message {
- Some(Ok(LoginRequest {
- data: Some(WalletLoginRequest(req)),
- })) => {
- let wallet_login_result =
- wallet_login_helper(client, req, &mut OsRng).await;
- if let Err(e) = tx.send(wallet_login_result).await {
- error!("Response was dropped: {}", e);
- Err(Status::aborted("failure"))
- } else {
- Ok(None)
- }
- }
- Some(Ok(LoginRequest {
- data:
- Some(PakeLoginRequest(PakeLoginRequestStruct {
- data:
- Some(PakeCredentialRequestAndUserId(
- pake_credential_request_and_user_id,
- )),
- })),
- })) => {
- let response_and_state = match pake_login_start(
- client,
- &pake_credential_request_and_user_id.user_id,
- &pake_credential_request_and_user_id.pake_credential_request,
- )
- .await
- {
- Ok(r) => r,
- Err(e) => {
- send_to_client(&tx, Err(e.clone())).await?;
- return Err(e);
- }
- };
- let login_response = LoginResponse {
- data: Some(PakeLoginResponse(response_and_state.response)),
- };
- if let Err(e) = tx.send(Ok(login_response)).await {
- error!("Response was dropped: {}", e);
- return Err(Status::aborted("failure"));
- }
-
- Ok(Some(LoginState {
- user_id: pake_credential_request_and_user_id.user_id,
- signing_public_key: pake_credential_request_and_user_id
- .signing_public_key,
- pake_state: response_and_state.pake_state,
- session_initialization_info: pake_credential_request_and_user_id
- .session_initialization_info
- .ok_or_else(|| Status::invalid_argument("Invalid message"))?
- .info,
- }))
- }
- Some(_) | None => Err(Status::aborted("failure")),
- }
-}
-
-pub async fn handle_credential_finalization(
- message: Option<Result<LoginRequest, Status>>,
- tx: mpsc::Sender<Result<LoginResponse, Status>>,
- client: &DatabaseClient,
- login_state: LoginState,
-) -> Result<(), Status> {
- match message {
- Some(Ok(LoginRequest {
- data:
- Some(PakeLoginRequest(PakeLoginRequestStruct {
- data: Some(PakeCredentialFinalization(pake_credential_finalization)),
- })),
- })) => {
- let login_finish_result = pake_login_finish(
- &login_state.user_id,
- &login_state.signing_public_key,
- client,
- login_state.pake_state,
- &pake_credential_finalization,
- &mut OsRng,
- PakeWorkflow::Login,
- &login_state.session_initialization_info,
- )
- .await
- .map(|pake_login_response| LoginResponse {
- data: Some(PakeLoginResponse(pake_login_response)),
- });
- if let Err(e) = tx.send(login_finish_result).await {
- error!("Response was dropped: {}", e);
- return Err(Status::aborted("failure"));
- }
- Ok(())
- }
- Some(_) | None => Err(Status::aborted("failure")),
- }
-}
diff --git a/services/identity/src/service/registration.rs b/services/identity/src/service/registration.rs
deleted file mode 100644
--- a/services/identity/src/service/registration.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use super::*;
-pub struct RegistrationState {
- user_id: String,
- username: String,
- signing_public_key: String,
- pub pake_state: Option<ServerRegistration<Cipher>>,
- session_initialization_info: HashMap<String, String>,
-}
-
-pub async fn handle_registration_request(
- message: Option<Result<RegistrationRequest, Status>>,
- client: &DatabaseClient,
- tx: mpsc::Sender<Result<RegistrationResponse, Status>>,
-) -> Result<RegistrationState, Status> {
- match message {
- Some(Ok(RegistrationRequest {
- data:
- Some(PakeRegistrationRequestAndUserId(
- pake_registration_request_and_user_id,
- )),
- })) => {
- let get_item_output = client
- .get_item_from_users_table(
- &pake_registration_request_and_user_id.user_id,
- )
- .await;
- match get_item_output {
- Ok(GetItemOutput { item: Some(_), .. }) => {
- error!("User already exists");
- if let Err(e) = tx
- .send(Err(Status::already_exists("User already exists")))
- .await
- {
- error!("Response was dropped: {}", e);
- }
- }
- Err(e) => return Err(handle_db_error(e)),
- _ => {}
- };
- let response_and_state = server_register_response(
- &pake_registration_request_and_user_id.pake_registration_request,
- )
- .await?;
- if let Err(e) = tx.send(Ok(response_and_state.response)).await {
- error!("Response was dropped: {}", e);
- }
-
- Ok(RegistrationState {
- user_id: pake_registration_request_and_user_id.user_id,
- username: pake_registration_request_and_user_id.username,
- signing_public_key: pake_registration_request_and_user_id
- .signing_public_key,
- pake_state: Some(response_and_state.pake_state),
- session_initialization_info: pake_registration_request_and_user_id
- .session_initialization_info
- .ok_or_else(|| Status::invalid_argument("Invalid message"))?
- .info,
- })
- }
- None | Some(_) => Err(Status::aborted("failure")),
- }
-}
-
-pub async fn handle_registration_upload_and_credential_request(
- message: Option<Result<RegistrationRequest, Status>>,
- tx: mpsc::Sender<Result<RegistrationResponse, Status>>,
- client: &DatabaseClient,
- registration_state: &RegistrationState,
- pake_state: ServerRegistration<Cipher>,
-) -> Result<ServerLogin<Cipher>, Status> {
- match message {
- Some(Ok(RegistrationRequest {
- data:
- Some(PakeRegistrationUploadAndCredentialRequest(
- pake_registration_upload_and_credential_request,
- )),
- })) => {
- let response_and_state = match pake_registration_finish(
- ®istration_state.user_id,
- client,
- &pake_registration_upload_and_credential_request
- .pake_registration_upload,
- pake_state,
- ®istration_state.username,
- ®istration_state.signing_public_key,
- ®istration_state.session_initialization_info,
- )
- .await
- {
- Ok(_) => {
- pake_login_start(
- client,
- ®istration_state.user_id,
- &pake_registration_upload_and_credential_request
- .pake_credential_request,
- )
- .await?
- }
-
- Err(e) => {
- return Err(e);
- }
- };
- let registration_response = RegistrationResponse {
- data: Some(PakeRegistrationLoginResponse(response_and_state.response)),
- };
- if let Err(e) = tx.send(Ok(registration_response)).await {
- error!("Response was dropped: {}", e);
- Err(Status::aborted("failure"))
- } else {
- Ok(response_and_state.pake_state)
- }
- }
- None | Some(_) => Err(Status::aborted("failure")),
- }
-}
-
-pub async fn handle_credential_finalization(
- message: Option<Result<RegistrationRequest, Status>>,
- tx: mpsc::Sender<Result<RegistrationResponse, Status>>,
- client: &DatabaseClient,
- registration_state: &RegistrationState,
- server_login: ServerLogin<Cipher>,
-) -> Result<(), Status> {
- match message {
- Some(Ok(RegistrationRequest {
- data:
- Some(PakeRegistrationCredentialFinalization(pake_credential_finalization)),
- })) => {
- let login_finish_result = pake_login_finish(
- ®istration_state.user_id,
- ®istration_state.signing_public_key,
- client,
- server_login,
- &pake_credential_finalization,
- &mut OsRng,
- PakeWorkflow::Registration,
- ®istration_state.session_initialization_info,
- )
- .await
- .map(|pake_login_response| RegistrationResponse {
- data: Some(PakeRegistrationLoginResponse(pake_login_response)),
- });
- if let Err(e) = tx.send(login_finish_result).await {
- error!("Response was dropped: {}", e);
- return Err(Status::aborted("failure"));
- }
- Ok(())
- }
- Some(_) | None => Err(Status::aborted("failure")),
- }
-}
diff --git a/services/identity/src/service/update.rs b/services/identity/src/service/update.rs
deleted file mode 100644
--- a/services/identity/src/service/update.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-use aws_sdk_dynamodb::output::GetItemOutput;
-use comm_opaque::Cipher;
-use opaque_ke::{ServerLogin, ServerRegistration};
-use rand::rngs::OsRng;
-use tokio::sync::mpsc;
-use tokio_stream::StreamExt;
-use tonic::Streaming;
-use tracing::{debug, error, info};
-
-use super::proto::{
- pake_login_response::Data::AccessToken, update_user_request,
- update_user_response, update_user_response::Data::PakeLoginResponse,
- update_user_response::Data::PakeRegistrationResponse,
- PakeRegistrationRequestAndUserId, PakeRegistrationUploadAndCredentialRequest,
-};
-use crate::service::PakeLoginResponseStruct;
-use crate::token::AuthType;
-use crate::{database::DatabaseClient, pake_grpc};
-
-use super::{
- handle_db_error, pake_login_start, put_token_helper, send_to_client, Status,
- UpdateUserRequest, UpdateUserResponse,
-};
-
-pub(crate) async fn handle_server_update_user_messages(
- in_stream: Streaming<UpdateUserRequest>,
- client: DatabaseClient,
- tx: tokio::sync::mpsc::Sender<Result<UpdateUserResponse, Status>>,
-) {
- match attempt_update_user(in_stream, &client, &tx).await {
- Ok(user_id) => info!("Successfully updated user {}", user_id),
- // Attempt to send client the failure to receive immediate feedback
- Err(e) => match send_to_client(&tx, Err(e)).await {
- Ok(_) => debug!("Attempted to inform user of failed update"),
- Err(_) => return,
- },
- };
-}
-
-async fn attempt_update_user(
- mut in_stream: Streaming<UpdateUserRequest>,
- client: &DatabaseClient,
- tx: &tokio::sync::mpsc::Sender<Result<UpdateUserResponse, Status>>,
-) -> Result<String, Status> {
- let first_message = in_stream.next().await;
-
- let (request, registration_state) =
- handle_registration_request(first_message, client, tx).await?;
-
- let second_message = in_stream.next().await;
- let registration_upload = get_registration_upload(second_message)?;
- let server_login = handle_registration_upload_and_credential_request(
- registration_upload,
- tx,
- &client,
- &request,
- registration_state,
- )
- .await?;
-
- let third_message = in_stream.next().await;
- let finalization_payload = get_finalization_message(third_message)?;
- handle_credential_finalization(
- finalization_payload,
- tx,
- client,
- &request,
- server_login,
- )
- .await?;
-
- Ok(request.user_id)
-}
-
-pub async fn handle_registration_request(
- message: Option<Result<UpdateUserRequest, Status>>,
- client: &DatabaseClient,
- tx: &mpsc::Sender<Result<UpdateUserResponse, Status>>,
-) -> Result<
- (PakeRegistrationRequestAndUserId, ServerRegistration<Cipher>),
- Status,
-> {
- let request = get_register_request(message)?;
- user_exists(&request.user_id, &client).await?;
- let server_registration_start_result = pake_grpc::server_registration_start(
- &mut OsRng,
- &request.pake_registration_request,
- )?;
- let server_start_payload =
- server_registration_start_result.message.serialize();
- let server_start_response = UpdateUserResponse {
- data: Some(PakeRegistrationResponse(server_start_payload)),
- };
- send_to_client(&tx, Ok(server_start_response)).await?;
-
- Ok((request, server_registration_start_result.state))
-}
-
-fn get_register_request(
- message: Option<Result<UpdateUserRequest, Status>>,
-) -> Result<PakeRegistrationRequestAndUserId, Status> {
- match message {
- Some(Ok(UpdateUserRequest {
- data: Some(update_user_request::Data::Request(request)),
- })) => Ok(request),
- e => {
- error!(
- "Expected to receive registration request, but instead received {:?}",
- e
- );
- Err(Status::invalid_argument("server error"))
- }
- }
-}
-
-fn get_finalization_message(
- message: Option<Result<UpdateUserRequest, Status>>,
-) -> Result<Vec<u8>, Status> {
- match message {
- Some(Ok(UpdateUserRequest {
- data:
- Some(update_user_request::Data::PakeLoginFinalizationMessage(request)),
- })) => Ok(request),
- e => {
- error!(
- "Expected to receive login finalization message, but instead received {:?}",
- e);
- Err(Status::aborted("server error"))
- }
- }
-}
-
-async fn user_exists(
- user_id: &str,
- client: &DatabaseClient,
-) -> Result<bool, Status> {
- match client
- .get_item_from_users_table(&user_id)
- .await
- .map_err(handle_db_error)
- {
- Ok(GetItemOutput { item: Some(_), .. }) => Ok(true),
- Ok(GetItemOutput { item: None, .. }) => {
- error!("Unable to find user: {}", user_id);
- return Err(Status::not_found("user not found"));
- }
- Err(e) => Err(e),
- }
-}
-
-pub async fn handle_registration_upload_and_credential_request(
- message: PakeRegistrationUploadAndCredentialRequest,
- tx: &mpsc::Sender<Result<UpdateUserResponse, Status>>,
- client: &DatabaseClient,
- request_and_user_info: &PakeRegistrationRequestAndUserId,
- pake_state: ServerRegistration<Cipher>,
-) -> Result<ServerLogin<Cipher>, Status> {
- pake_registration_finish(
- &request_and_user_info.user_id,
- client,
- &message.pake_registration_upload,
- pake_state,
- )
- .await?;
- let response_and_state = pake_login_start(
- client,
- &request_and_user_info.user_id,
- &message.pake_credential_request,
- )
- .await?;
-
- let registration_response = UpdateUserResponse {
- data: Some(PakeLoginResponse(response_and_state.response)),
- };
-
- send_to_client(tx, Ok(registration_response)).await?;
- Ok(response_and_state.pake_state)
-}
-
-async fn pake_registration_finish(
- user_id: &str,
- client: &DatabaseClient,
- registration_upload_bytes: &Vec<u8>,
- server_registration: ServerRegistration<Cipher>,
-) -> Result<(), Status> {
- if user_id.is_empty() {
- error!("Incomplete data: user ID not provided");
- return Err(Status::aborted("user not found"));
- }
- let server_registration_finish_result =
- pake_grpc::server_registration_finish(
- server_registration,
- registration_upload_bytes,
- )?;
-
- client
- .update_users_table(
- user_id.to_string(),
- None,
- Some(server_registration_finish_result),
- None,
- None,
- )
- .await
- .map_err(handle_db_error)?;
- Ok(())
-}
-
-fn get_registration_upload(
- message: Option<Result<UpdateUserRequest, Status>>,
-) -> Result<
- crate::service::proto::PakeRegistrationUploadAndCredentialRequest,
- Status,
-> {
- match message {
- Some(Ok(UpdateUserRequest {
- data:
- Some(
- update_user_request::Data::PakeRegistrationUploadAndCredentialRequest(
- upload,
- ),
- ),
- })) => Ok(upload),
- e => {
- error!(
- "Expected to receive registration upload, but instead received {:?}",
- e
- );
- Err(Status::aborted("server error"))
- }
- }
-}
-
-pub async fn handle_credential_finalization(
- finalization_payload: Vec<u8>,
- tx: &mpsc::Sender<Result<UpdateUserResponse, Status>>,
- client: &DatabaseClient,
- request_and_user_info: &PakeRegistrationRequestAndUserId,
- server_login: ServerLogin<Cipher>,
-) -> Result<(), Status> {
- let login_finish_result = pake_login_finish(
- &request_and_user_info.user_id,
- &request_and_user_info.signing_public_key,
- client,
- server_login,
- &finalization_payload,
- )
- .await?;
- let response = UpdateUserResponse {
- data: Some(update_user_response::Data::PakeLoginResponse(
- login_finish_result,
- )),
- };
- send_to_client(tx, Ok(response)).await
-}
-
-async fn pake_login_finish(
- user_id: &str,
- signing_public_key: &str,
- client: &DatabaseClient,
- server_login: ServerLogin<Cipher>,
- pake_credential_finalization: &Vec<u8>,
-) -> Result<PakeLoginResponseStruct, Status> {
- if user_id.is_empty() {
- error!("Incomplete data: user ID {}", user_id);
- return Err(Status::aborted("user not found"));
- }
-
- pake_grpc::server_login_finish(server_login, pake_credential_finalization)?;
- let access_token = put_token_helper(
- client,
- AuthType::Password,
- user_id,
- signing_public_key,
- &mut OsRng,
- )
- .await?;
- Ok(PakeLoginResponseStruct {
- data: Some(AccessToken(access_token)),
- })
-}
diff --git a/shared/protos/_generated/identity.grpc.pb.h b/shared/protos/_generated/identity.grpc.pb.h
deleted file mode 100644
--- a/shared/protos/_generated/identity.grpc.pb.h
+++ /dev/null
@@ -1,837 +0,0 @@
-// @generated by the gRPC C++ plugin.
-// If you make any local change, they will be lost.
-// source: identity.proto
-#ifndef GRPC_identity_2eproto__INCLUDED
-#define GRPC_identity_2eproto__INCLUDED
-
-#include "identity.pb.h"
-
-#include <functional>
-#include <grpcpp/impl/codegen/async_generic_service.h>
-#include <grpcpp/impl/codegen/async_stream.h>
-#include <grpcpp/impl/codegen/async_unary_call.h>
-#include <grpcpp/impl/codegen/client_callback.h>
-#include <grpcpp/impl/codegen/client_context.h>
-#include <grpcpp/impl/codegen/completion_queue.h>
-#include <grpcpp/impl/codegen/message_allocator.h>
-#include <grpcpp/impl/codegen/method_handler.h>
-#include <grpcpp/impl/codegen/proto_utils.h>
-#include <grpcpp/impl/codegen/rpc_method.h>
-#include <grpcpp/impl/codegen/server_callback.h>
-#include <grpcpp/impl/codegen/server_callback_handlers.h>
-#include <grpcpp/impl/codegen/server_context.h>
-#include <grpcpp/impl/codegen/service_type.h>
-#include <grpcpp/impl/codegen/status.h>
-#include <grpcpp/impl/codegen/stub_options.h>
-#include <grpcpp/impl/codegen/sync_stream.h>
-
-namespace identity {
-
-class IdentityService final {
- public:
- static constexpr char const* service_full_name() {
- return "identity.IdentityService";
- }
- class StubInterface {
- public:
- virtual ~StubInterface() {}
- // Called by user to register with the Identity Service (PAKE only)
- std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> RegisterUser(::grpc::ClientContext* context) {
- return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(RegisterUserRaw(context));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> AsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(AsyncRegisterUserRaw(context, cq, tag));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> PrepareAsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(PrepareAsyncRegisterUserRaw(context, cq));
- }
- // Called by user to create an active session and get an access token
- std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> LoginUser(::grpc::ClientContext* context) {
- return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(LoginUserRaw(context));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> AsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(AsyncLoginUserRaw(context, cq, tag));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>> PrepareAsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>>(PrepareAsyncLoginUserRaw(context, cq));
- }
- // Called by other services to verify a user's token
- virtual ::grpc::Status VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) = 0;
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>> AsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>>(AsyncVerifyUserTokenRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>> PrepareAsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>>(PrepareAsyncVerifyUserTokenRaw(context, request, cq));
- }
- // Called by users and keyservers to get userID corresponding to a wallet
- // address or username
- virtual ::grpc::Status GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::identity::GetUserIDResponse* response) = 0;
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>> AsyncGetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>>(AsyncGetUserIDRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>> PrepareAsyncGetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>>(PrepareAsyncGetUserIDRaw(context, request, cq));
- }
- // Called by keyservers to get the public key corresponding to a given user ID
- // and device ID
- virtual ::grpc::Status GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::identity::GetUserPublicKeyResponse* response) = 0;
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>> AsyncGetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>>(AsyncGetUserPublicKeyRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>> PrepareAsyncGetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>>(PrepareAsyncGetUserPublicKeyRaw(context, request, cq));
- }
- class async_interface {
- public:
- virtual ~async_interface() {}
- // Called by user to register with the Identity Service (PAKE only)
- virtual void RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) = 0;
- // Called by user to create an active session and get an access token
- virtual void LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) = 0;
- // Called by other services to verify a user's token
- virtual void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)>) = 0;
- virtual void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
- // Called by users and keyservers to get userID corresponding to a wallet
- // address or username
- virtual void GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, std::function<void(::grpc::Status)>) = 0;
- virtual void GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0;
- // Called by keyservers to get the public key corresponding to a given user ID
- // and device ID
- virtual void GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, std::function<void(::grpc::Status)>) = 0;
- virtual void GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, ::grpc::ClientUnaryReactor* 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::ClientReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUserRaw(::grpc::ClientContext* context) = 0;
- virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
- virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUserRaw(::grpc::ClientContext* context) = 0;
- virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0;
- virtual ::grpc::ClientAsyncReaderWriterInterface< ::identity::LoginRequest, ::identity::LoginResponse>* PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>* AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::VerifyUserTokenResponse>* PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>* AsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserIDResponse>* PrepareAsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>* AsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) = 0;
- virtual ::grpc::ClientAsyncResponseReaderInterface< ::identity::GetUserPublicKeyResponse>* PrepareAsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::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::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> RegisterUser(::grpc::ClientContext* context) {
- return std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(RegisterUserRaw(context));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> AsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(AsyncRegisterUserRaw(context, cq, tag));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>> PrepareAsyncRegisterUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>>(PrepareAsyncRegisterUserRaw(context, cq));
- }
- std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> LoginUser(::grpc::ClientContext* context) {
- return std::unique_ptr< ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(LoginUserRaw(context));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> AsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(AsyncLoginUserRaw(context, cq, tag));
- }
- std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>> PrepareAsyncLoginUser(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>>(PrepareAsyncLoginUserRaw(context, cq));
- }
- ::grpc::Status VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) override;
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>> AsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>>(AsyncVerifyUserTokenRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>> PrepareAsyncVerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>>(PrepareAsyncVerifyUserTokenRaw(context, request, cq));
- }
- ::grpc::Status GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::identity::GetUserIDResponse* response) override;
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>> AsyncGetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>>(AsyncGetUserIDRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>> PrepareAsyncGetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>>(PrepareAsyncGetUserIDRaw(context, request, cq));
- }
- ::grpc::Status GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::identity::GetUserPublicKeyResponse* response) override;
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>> AsyncGetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>>(AsyncGetUserPublicKeyRaw(context, request, cq));
- }
- std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>> PrepareAsyncGetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>>(PrepareAsyncGetUserPublicKeyRaw(context, request, cq));
- }
- class async final :
- public StubInterface::async_interface {
- public:
- void RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) override;
- void LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) override;
- void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)>) override;
- void VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
- void GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, std::function<void(::grpc::Status)>) override;
- void GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
- void GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, std::function<void(::grpc::Status)>) override;
- void GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) override;
- private:
- friend class Stub;
- explicit async(Stub* stub): stub_(stub) { }
- Stub* stub() { return stub_; }
- Stub* stub_;
- };
- class async* async() override { return &async_stub_; }
-
- private:
- std::shared_ptr< ::grpc::ChannelInterface> channel_;
- class async async_stub_{this};
- ::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUserRaw(::grpc::ClientContext* context) override;
- ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
- ::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUserRaw(::grpc::ClientContext* context) override;
- ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override;
- ::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>* AsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>* PrepareAsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>* AsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) override;
- ::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>* PrepareAsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) override;
- const ::grpc::internal::RpcMethod rpcmethod_RegisterUser_;
- const ::grpc::internal::RpcMethod rpcmethod_LoginUser_;
- const ::grpc::internal::RpcMethod rpcmethod_VerifyUserToken_;
- const ::grpc::internal::RpcMethod rpcmethod_GetUserID_;
- const ::grpc::internal::RpcMethod rpcmethod_GetUserPublicKey_;
- };
- static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
-
- class Service : public ::grpc::Service {
- public:
- Service();
- virtual ~Service();
- // Called by user to register with the Identity Service (PAKE only)
- virtual ::grpc::Status RegisterUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* stream);
- // Called by user to create an active session and get an access token
- virtual ::grpc::Status LoginUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream);
- // Called by other services to verify a user's token
- virtual ::grpc::Status VerifyUserToken(::grpc::ServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response);
- // Called by users and keyservers to get userID corresponding to a wallet
- // address or username
- virtual ::grpc::Status GetUserID(::grpc::ServerContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response);
- // Called by keyservers to get the public key corresponding to a given user ID
- // and device ID
- virtual ::grpc::Status GetUserPublicKey(::grpc::ServerContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response);
- };
- template <class BaseClass>
- class WithAsyncMethod_RegisterUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithAsyncMethod_RegisterUser() {
- ::grpc::Service::MarkMethodAsync(0);
- }
- ~WithAsyncMethod_RegisterUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status RegisterUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestRegisterUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* 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>
- class WithAsyncMethod_LoginUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithAsyncMethod_LoginUser() {
- ::grpc::Service::MarkMethodAsync(1);
- }
- ~WithAsyncMethod_LoginUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status LoginUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestLoginUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag);
- }
- };
- template <class BaseClass>
- class WithAsyncMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithAsyncMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodAsync(2);
- }
- ~WithAsyncMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestVerifyUserToken(::grpc::ServerContext* context, ::identity::VerifyUserTokenRequest* request, ::grpc::ServerAsyncResponseWriter< ::identity::VerifyUserTokenResponse>* 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);
- }
- };
- template <class BaseClass>
- class WithAsyncMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithAsyncMethod_GetUserID() {
- ::grpc::Service::MarkMethodAsync(3);
- }
- ~WithAsyncMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestGetUserID(::grpc::ServerContext* context, ::identity::GetUserIDRequest* request, ::grpc::ServerAsyncResponseWriter< ::identity::GetUserIDResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
- }
- };
- template <class BaseClass>
- class WithAsyncMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithAsyncMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodAsync(4);
- }
- ~WithAsyncMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestGetUserPublicKey(::grpc::ServerContext* context, ::identity::GetUserPublicKeyRequest* request, ::grpc::ServerAsyncResponseWriter< ::identity::GetUserPublicKeyResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
- }
- };
- typedef WithAsyncMethod_RegisterUser<WithAsyncMethod_LoginUser<WithAsyncMethod_VerifyUserToken<WithAsyncMethod_GetUserID<WithAsyncMethod_GetUserPublicKey<Service > > > > > AsyncService;
- template <class BaseClass>
- class WithCallbackMethod_RegisterUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithCallbackMethod_RegisterUser() {
- ::grpc::Service::MarkMethodCallback(0,
- new ::grpc::internal::CallbackBidiHandler< ::identity::RegistrationRequest, ::identity::RegistrationResponse>(
- [this](
- ::grpc::CallbackServerContext* context) { return this->RegisterUser(context); }));
- }
- ~WithCallbackMethod_RegisterUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status RegisterUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerBidiReactor< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* RegisterUser(
- ::grpc::CallbackServerContext* /*context*/)
- { return nullptr; }
- };
- template <class BaseClass>
- class WithCallbackMethod_LoginUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithCallbackMethod_LoginUser() {
- ::grpc::Service::MarkMethodCallback(1,
- new ::grpc::internal::CallbackBidiHandler< ::identity::LoginRequest, ::identity::LoginResponse>(
- [this](
- ::grpc::CallbackServerContext* context) { return this->LoginUser(context); }));
- }
- ~WithCallbackMethod_LoginUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status LoginUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerBidiReactor< ::identity::LoginRequest, ::identity::LoginResponse>* LoginUser(
- ::grpc::CallbackServerContext* /*context*/)
- { return nullptr; }
- };
- template <class BaseClass>
- class WithCallbackMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithCallbackMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodCallback(2,
- new ::grpc::internal::CallbackUnaryHandler< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>(
- [this](
- ::grpc::CallbackServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response) { return this->VerifyUserToken(context, request, response); }));}
- void SetMessageAllocatorFor_VerifyUserToken(
- ::grpc::MessageAllocator< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>* allocator) {
- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
- static_cast<::grpc::internal::CallbackUnaryHandler< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>*>(handler)
- ->SetMessageAllocator(allocator);
- }
- ~WithCallbackMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* VerifyUserToken(
- ::grpc::CallbackServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithCallbackMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithCallbackMethod_GetUserID() {
- ::grpc::Service::MarkMethodCallback(3,
- new ::grpc::internal::CallbackUnaryHandler< ::identity::GetUserIDRequest, ::identity::GetUserIDResponse>(
- [this](
- ::grpc::CallbackServerContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response) { return this->GetUserID(context, request, response); }));}
- void SetMessageAllocatorFor_GetUserID(
- ::grpc::MessageAllocator< ::identity::GetUserIDRequest, ::identity::GetUserIDResponse>* allocator) {
- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3);
- static_cast<::grpc::internal::CallbackUnaryHandler< ::identity::GetUserIDRequest, ::identity::GetUserIDResponse>*>(handler)
- ->SetMessageAllocator(allocator);
- }
- ~WithCallbackMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* GetUserID(
- ::grpc::CallbackServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithCallbackMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithCallbackMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodCallback(4,
- new ::grpc::internal::CallbackUnaryHandler< ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse>(
- [this](
- ::grpc::CallbackServerContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response) { return this->GetUserPublicKey(context, request, response); }));}
- void SetMessageAllocatorFor_GetUserPublicKey(
- ::grpc::MessageAllocator< ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse>* allocator) {
- ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4);
- static_cast<::grpc::internal::CallbackUnaryHandler< ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse>*>(handler)
- ->SetMessageAllocator(allocator);
- }
- ~WithCallbackMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* GetUserPublicKey(
- ::grpc::CallbackServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) { return nullptr; }
- };
- typedef WithCallbackMethod_RegisterUser<WithCallbackMethod_LoginUser<WithCallbackMethod_VerifyUserToken<WithCallbackMethod_GetUserID<WithCallbackMethod_GetUserPublicKey<Service > > > > > CallbackService;
- typedef CallbackService ExperimentalCallbackService;
- template <class BaseClass>
- class WithGenericMethod_RegisterUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithGenericMethod_RegisterUser() {
- ::grpc::Service::MarkMethodGeneric(0);
- }
- ~WithGenericMethod_RegisterUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status RegisterUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- };
- template <class BaseClass>
- class WithGenericMethod_LoginUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithGenericMethod_LoginUser() {
- ::grpc::Service::MarkMethodGeneric(1);
- }
- ~WithGenericMethod_LoginUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status LoginUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- };
- template <class BaseClass>
- class WithGenericMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithGenericMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodGeneric(2);
- }
- ~WithGenericMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- };
- template <class BaseClass>
- class WithGenericMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithGenericMethod_GetUserID() {
- ::grpc::Service::MarkMethodGeneric(3);
- }
- ~WithGenericMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- };
- template <class BaseClass>
- class WithGenericMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithGenericMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodGeneric(4);
- }
- ~WithGenericMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- };
- template <class BaseClass>
- class WithRawMethod_RegisterUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawMethod_RegisterUser() {
- ::grpc::Service::MarkMethodRaw(0);
- }
- ~WithRawMethod_RegisterUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status RegisterUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestRegisterUser(::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>
- class WithRawMethod_LoginUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawMethod_LoginUser() {
- ::grpc::Service::MarkMethodRaw(1);
- }
- ~WithRawMethod_LoginUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status LoginUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestLoginUser(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncBidiStreaming(1, context, stream, new_call_cq, notification_cq, tag);
- }
- };
- template <class BaseClass>
- class WithRawMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodRaw(2);
- }
- ~WithRawMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestVerifyUserToken(::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);
- }
- };
- template <class BaseClass>
- class WithRawMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawMethod_GetUserID() {
- ::grpc::Service::MarkMethodRaw(3);
- }
- ~WithRawMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestGetUserID(::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(3, context, request, response, new_call_cq, notification_cq, tag);
- }
- };
- template <class BaseClass>
- class WithRawMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodRaw(4);
- }
- ~WithRawMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- void RequestGetUserPublicKey(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
- ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
- }
- };
- template <class BaseClass>
- class WithRawCallbackMethod_RegisterUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawCallbackMethod_RegisterUser() {
- ::grpc::Service::MarkMethodRawCallback(0,
- new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
- [this](
- ::grpc::CallbackServerContext* context) { return this->RegisterUser(context); }));
- }
- ~WithRawCallbackMethod_RegisterUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status RegisterUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* RegisterUser(
- ::grpc::CallbackServerContext* /*context*/)
- { return nullptr; }
- };
- template <class BaseClass>
- class WithRawCallbackMethod_LoginUser : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawCallbackMethod_LoginUser() {
- ::grpc::Service::MarkMethodRawCallback(1,
- new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
- [this](
- ::grpc::CallbackServerContext* context) { return this->LoginUser(context); }));
- }
- ~WithRawCallbackMethod_LoginUser() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status LoginUser(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* /*stream*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* LoginUser(
- ::grpc::CallbackServerContext* /*context*/)
- { return nullptr; }
- };
- template <class BaseClass>
- class WithRawCallbackMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawCallbackMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodRawCallback(2,
- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
- [this](
- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->VerifyUserToken(context, request, response); }));
- }
- ~WithRawCallbackMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* VerifyUserToken(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithRawCallbackMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawCallbackMethod_GetUserID() {
- ::grpc::Service::MarkMethodRawCallback(3,
- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
- [this](
- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetUserID(context, request, response); }));
- }
- ~WithRawCallbackMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* GetUserID(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithRawCallbackMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithRawCallbackMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodRawCallback(4,
- new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
- [this](
- ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->GetUserPublicKey(context, request, response); }));
- }
- ~WithRawCallbackMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable synchronous version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- virtual ::grpc::ServerUnaryReactor* GetUserPublicKey(
- ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; }
- };
- template <class BaseClass>
- class WithStreamedUnaryMethod_VerifyUserToken : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithStreamedUnaryMethod_VerifyUserToken() {
- ::grpc::Service::MarkMethodStreamed(2,
- new ::grpc::internal::StreamedUnaryHandler<
- ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerUnaryStreamer<
- ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse>* streamer) {
- return this->StreamedVerifyUserToken(context,
- streamer);
- }));
- }
- ~WithStreamedUnaryMethod_VerifyUserToken() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status VerifyUserToken(::grpc::ServerContext* /*context*/, const ::identity::VerifyUserTokenRequest* /*request*/, ::identity::VerifyUserTokenResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- // replace default version of method with streamed unary
- virtual ::grpc::Status StreamedVerifyUserToken(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::identity::VerifyUserTokenRequest,::identity::VerifyUserTokenResponse>* server_unary_streamer) = 0;
- };
- template <class BaseClass>
- class WithStreamedUnaryMethod_GetUserID : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithStreamedUnaryMethod_GetUserID() {
- ::grpc::Service::MarkMethodStreamed(3,
- new ::grpc::internal::StreamedUnaryHandler<
- ::identity::GetUserIDRequest, ::identity::GetUserIDResponse>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerUnaryStreamer<
- ::identity::GetUserIDRequest, ::identity::GetUserIDResponse>* streamer) {
- return this->StreamedGetUserID(context,
- streamer);
- }));
- }
- ~WithStreamedUnaryMethod_GetUserID() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status GetUserID(::grpc::ServerContext* /*context*/, const ::identity::GetUserIDRequest* /*request*/, ::identity::GetUserIDResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- // replace default version of method with streamed unary
- virtual ::grpc::Status StreamedGetUserID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::identity::GetUserIDRequest,::identity::GetUserIDResponse>* server_unary_streamer) = 0;
- };
- template <class BaseClass>
- class WithStreamedUnaryMethod_GetUserPublicKey : public BaseClass {
- private:
- void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
- public:
- WithStreamedUnaryMethod_GetUserPublicKey() {
- ::grpc::Service::MarkMethodStreamed(4,
- new ::grpc::internal::StreamedUnaryHandler<
- ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse>(
- [this](::grpc::ServerContext* context,
- ::grpc::ServerUnaryStreamer<
- ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse>* streamer) {
- return this->StreamedGetUserPublicKey(context,
- streamer);
- }));
- }
- ~WithStreamedUnaryMethod_GetUserPublicKey() override {
- BaseClassMustBeDerivedFromService(this);
- }
- // disable regular version of this method
- ::grpc::Status GetUserPublicKey(::grpc::ServerContext* /*context*/, const ::identity::GetUserPublicKeyRequest* /*request*/, ::identity::GetUserPublicKeyResponse* /*response*/) override {
- abort();
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
- }
- // replace default version of method with streamed unary
- virtual ::grpc::Status StreamedGetUserPublicKey(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::identity::GetUserPublicKeyRequest,::identity::GetUserPublicKeyResponse>* server_unary_streamer) = 0;
- };
- typedef WithStreamedUnaryMethod_VerifyUserToken<WithStreamedUnaryMethod_GetUserID<WithStreamedUnaryMethod_GetUserPublicKey<Service > > > StreamedUnaryService;
- typedef Service SplitStreamedService;
- typedef WithStreamedUnaryMethod_VerifyUserToken<WithStreamedUnaryMethod_GetUserID<WithStreamedUnaryMethod_GetUserPublicKey<Service > > > StreamedService;
-};
-
-} // namespace identity
-
-
-#endif // GRPC_identity_2eproto__INCLUDED
diff --git a/shared/protos/_generated/identity.grpc.pb.cc b/shared/protos/_generated/identity.grpc.pb.cc
deleted file mode 100644
--- a/shared/protos/_generated/identity.grpc.pb.cc
+++ /dev/null
@@ -1,238 +0,0 @@
-// @generated by the gRPC C++ plugin.
-// If you make any local change, they will be lost.
-// source: identity.proto
-
-#include "identity.pb.h"
-#include "identity.grpc.pb.h"
-
-#include <functional>
-#include <grpcpp/impl/codegen/async_stream.h>
-#include <grpcpp/impl/codegen/async_unary_call.h>
-#include <grpcpp/impl/codegen/channel_interface.h>
-#include <grpcpp/impl/codegen/client_unary_call.h>
-#include <grpcpp/impl/codegen/client_callback.h>
-#include <grpcpp/impl/codegen/message_allocator.h>
-#include <grpcpp/impl/codegen/method_handler.h>
-#include <grpcpp/impl/codegen/rpc_service_method.h>
-#include <grpcpp/impl/codegen/server_callback.h>
-#include <grpcpp/impl/codegen/server_callback_handlers.h>
-#include <grpcpp/impl/codegen/server_context.h>
-#include <grpcpp/impl/codegen/service_type.h>
-#include <grpcpp/impl/codegen/sync_stream.h>
-namespace identity {
-
-static const char* IdentityService_method_names[] = {
- "/identity.IdentityService/RegisterUser",
- "/identity.IdentityService/LoginUser",
- "/identity.IdentityService/VerifyUserToken",
- "/identity.IdentityService/GetUserID",
- "/identity.IdentityService/GetUserPublicKey",
-};
-
-std::unique_ptr< IdentityService::Stub> IdentityService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
- (void)options;
- std::unique_ptr< IdentityService::Stub> stub(new IdentityService::Stub(channel, options));
- return stub;
-}
-
-IdentityService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options)
- : channel_(channel), rpcmethod_RegisterUser_(IdentityService_method_names[0], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
- , rpcmethod_LoginUser_(IdentityService_method_names[1], options.suffix_for_stats(),::grpc::internal::RpcMethod::BIDI_STREAMING, channel)
- , rpcmethod_VerifyUserToken_(IdentityService_method_names[2], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
- , rpcmethod_GetUserID_(IdentityService_method_names[3], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
- , rpcmethod_GetUserPublicKey_(IdentityService_method_names[4], options.suffix_for_stats(),::grpc::internal::RpcMethod::NORMAL_RPC, channel)
- {}
-
-::grpc::ClientReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::RegisterUserRaw(::grpc::ClientContext* context) {
- return ::grpc::internal::ClientReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), rpcmethod_RegisterUser_, context);
-}
-
-void IdentityService::Stub::async::RegisterUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::RegistrationRequest,::identity::RegistrationResponse>* reactor) {
- ::grpc::internal::ClientCallbackReaderWriterFactory< ::identity::RegistrationRequest,::identity::RegistrationResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_RegisterUser_, context, reactor);
-}
-
-::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::AsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), cq, rpcmethod_RegisterUser_, context, true, tag);
-}
-
-::grpc::ClientAsyncReaderWriter< ::identity::RegistrationRequest, ::identity::RegistrationResponse>* IdentityService::Stub::PrepareAsyncRegisterUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::RegistrationRequest, ::identity::RegistrationResponse>::Create(channel_.get(), cq, rpcmethod_RegisterUser_, context, false, nullptr);
-}
-
-::grpc::ClientReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::LoginUserRaw(::grpc::ClientContext* context) {
- return ::grpc::internal::ClientReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), rpcmethod_LoginUser_, context);
-}
-
-void IdentityService::Stub::async::LoginUser(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::identity::LoginRequest,::identity::LoginResponse>* reactor) {
- ::grpc::internal::ClientCallbackReaderWriterFactory< ::identity::LoginRequest,::identity::LoginResponse>::Create(stub_->channel_.get(), stub_->rpcmethod_LoginUser_, context, reactor);
-}
-
-::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::AsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
- return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), cq, rpcmethod_LoginUser_, context, true, tag);
-}
-
-::grpc::ClientAsyncReaderWriter< ::identity::LoginRequest, ::identity::LoginResponse>* IdentityService::Stub::PrepareAsyncLoginUserRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncReaderWriterFactory< ::identity::LoginRequest, ::identity::LoginResponse>::Create(channel_.get(), cq, rpcmethod_LoginUser_, context, false, nullptr);
-}
-
-::grpc::Status IdentityService::Stub::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::identity::VerifyUserTokenResponse* response) {
- return ::grpc::internal::BlockingUnaryCall< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_VerifyUserToken_, context, request, response);
-}
-
-void IdentityService::Stub::async::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, std::function<void(::grpc::Status)> f) {
- ::grpc::internal::CallbackUnaryCall< ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_VerifyUserToken_, context, request, response, std::move(f));
-}
-
-void IdentityService::Stub::async::VerifyUserToken(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response, ::grpc::ClientUnaryReactor* reactor) {
- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_VerifyUserToken_, context, request, response, reactor);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* IdentityService::Stub::PrepareAsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::identity::VerifyUserTokenResponse, ::identity::VerifyUserTokenRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_VerifyUserToken_, context, request);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::VerifyUserTokenResponse>* IdentityService::Stub::AsyncVerifyUserTokenRaw(::grpc::ClientContext* context, const ::identity::VerifyUserTokenRequest& request, ::grpc::CompletionQueue* cq) {
- auto* result =
- this->PrepareAsyncVerifyUserTokenRaw(context, request, cq);
- result->StartCall();
- return result;
-}
-
-::grpc::Status IdentityService::Stub::GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::identity::GetUserIDResponse* response) {
- return ::grpc::internal::BlockingUnaryCall< ::identity::GetUserIDRequest, ::identity::GetUserIDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetUserID_, context, request, response);
-}
-
-void IdentityService::Stub::async::GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, std::function<void(::grpc::Status)> f) {
- ::grpc::internal::CallbackUnaryCall< ::identity::GetUserIDRequest, ::identity::GetUserIDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetUserID_, context, request, response, std::move(f));
-}
-
-void IdentityService::Stub::async::GetUserID(::grpc::ClientContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response, ::grpc::ClientUnaryReactor* reactor) {
- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetUserID_, context, request, response, reactor);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>* IdentityService::Stub::PrepareAsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::identity::GetUserIDResponse, ::identity::GetUserIDRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetUserID_, context, request);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::GetUserIDResponse>* IdentityService::Stub::AsyncGetUserIDRaw(::grpc::ClientContext* context, const ::identity::GetUserIDRequest& request, ::grpc::CompletionQueue* cq) {
- auto* result =
- this->PrepareAsyncGetUserIDRaw(context, request, cq);
- result->StartCall();
- return result;
-}
-
-::grpc::Status IdentityService::Stub::GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::identity::GetUserPublicKeyResponse* response) {
- return ::grpc::internal::BlockingUnaryCall< ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_GetUserPublicKey_, context, request, response);
-}
-
-void IdentityService::Stub::async::GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, std::function<void(::grpc::Status)> f) {
- ::grpc::internal::CallbackUnaryCall< ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetUserPublicKey_, context, request, response, std::move(f));
-}
-
-void IdentityService::Stub::async::GetUserPublicKey(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response, ::grpc::ClientUnaryReactor* reactor) {
- ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_GetUserPublicKey_, context, request, response, reactor);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>* IdentityService::Stub::PrepareAsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::identity::GetUserPublicKeyResponse, ::identity::GetUserPublicKeyRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_GetUserPublicKey_, context, request);
-}
-
-::grpc::ClientAsyncResponseReader< ::identity::GetUserPublicKeyResponse>* IdentityService::Stub::AsyncGetUserPublicKeyRaw(::grpc::ClientContext* context, const ::identity::GetUserPublicKeyRequest& request, ::grpc::CompletionQueue* cq) {
- auto* result =
- this->PrepareAsyncGetUserPublicKeyRaw(context, request, cq);
- result->StartCall();
- return result;
-}
-
-IdentityService::Service::Service() {
- AddMethod(new ::grpc::internal::RpcServiceMethod(
- IdentityService_method_names[0],
- ::grpc::internal::RpcMethod::BIDI_STREAMING,
- new ::grpc::internal::BidiStreamingHandler< IdentityService::Service, ::identity::RegistrationRequest, ::identity::RegistrationResponse>(
- [](IdentityService::Service* service,
- ::grpc::ServerContext* ctx,
- ::grpc::ServerReaderWriter<::identity::RegistrationResponse,
- ::identity::RegistrationRequest>* stream) {
- return service->RegisterUser(ctx, stream);
- }, this)));
- AddMethod(new ::grpc::internal::RpcServiceMethod(
- IdentityService_method_names[1],
- ::grpc::internal::RpcMethod::BIDI_STREAMING,
- new ::grpc::internal::BidiStreamingHandler< IdentityService::Service, ::identity::LoginRequest, ::identity::LoginResponse>(
- [](IdentityService::Service* service,
- ::grpc::ServerContext* ctx,
- ::grpc::ServerReaderWriter<::identity::LoginResponse,
- ::identity::LoginRequest>* stream) {
- return service->LoginUser(ctx, stream);
- }, this)));
- AddMethod(new ::grpc::internal::RpcServiceMethod(
- IdentityService_method_names[2],
- ::grpc::internal::RpcMethod::NORMAL_RPC,
- new ::grpc::internal::RpcMethodHandler< IdentityService::Service, ::identity::VerifyUserTokenRequest, ::identity::VerifyUserTokenResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
- [](IdentityService::Service* service,
- ::grpc::ServerContext* ctx,
- const ::identity::VerifyUserTokenRequest* req,
- ::identity::VerifyUserTokenResponse* resp) {
- return service->VerifyUserToken(ctx, req, resp);
- }, this)));
- AddMethod(new ::grpc::internal::RpcServiceMethod(
- IdentityService_method_names[3],
- ::grpc::internal::RpcMethod::NORMAL_RPC,
- new ::grpc::internal::RpcMethodHandler< IdentityService::Service, ::identity::GetUserIDRequest, ::identity::GetUserIDResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
- [](IdentityService::Service* service,
- ::grpc::ServerContext* ctx,
- const ::identity::GetUserIDRequest* req,
- ::identity::GetUserIDResponse* resp) {
- return service->GetUserID(ctx, req, resp);
- }, this)));
- AddMethod(new ::grpc::internal::RpcServiceMethod(
- IdentityService_method_names[4],
- ::grpc::internal::RpcMethod::NORMAL_RPC,
- new ::grpc::internal::RpcMethodHandler< IdentityService::Service, ::identity::GetUserPublicKeyRequest, ::identity::GetUserPublicKeyResponse, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
- [](IdentityService::Service* service,
- ::grpc::ServerContext* ctx,
- const ::identity::GetUserPublicKeyRequest* req,
- ::identity::GetUserPublicKeyResponse* resp) {
- return service->GetUserPublicKey(ctx, req, resp);
- }, this)));
-}
-
-IdentityService::Service::~Service() {
-}
-
-::grpc::Status IdentityService::Service::RegisterUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::RegistrationResponse, ::identity::RegistrationRequest>* stream) {
- (void) context;
- (void) stream;
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-::grpc::Status IdentityService::Service::LoginUser(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::identity::LoginResponse, ::identity::LoginRequest>* stream) {
- (void) context;
- (void) stream;
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-::grpc::Status IdentityService::Service::VerifyUserToken(::grpc::ServerContext* context, const ::identity::VerifyUserTokenRequest* request, ::identity::VerifyUserTokenResponse* response) {
- (void) context;
- (void) request;
- (void) response;
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-::grpc::Status IdentityService::Service::GetUserID(::grpc::ServerContext* context, const ::identity::GetUserIDRequest* request, ::identity::GetUserIDResponse* response) {
- (void) context;
- (void) request;
- (void) response;
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-::grpc::Status IdentityService::Service::GetUserPublicKey(::grpc::ServerContext* context, const ::identity::GetUserPublicKeyRequest* request, ::identity::GetUserPublicKeyResponse* response) {
- (void) context;
- (void) request;
- (void) response;
- return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-
-} // namespace identity
-
diff --git a/shared/protos/_generated/identity.pb.h b/shared/protos/_generated/identity.pb.h
deleted file mode 100644
--- a/shared/protos/_generated/identity.pb.h
+++ /dev/null
@@ -1,6068 +0,0 @@
-// @generated by the protocol buffer compiler. DO NOT EDIT!
-// source: identity.proto
-
-#ifndef GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
-#define GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
-
-#include <limits>
-#include <string>
-
-#include <google/protobuf/port_def.inc>
-#if PROTOBUF_VERSION < 3015000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please update
-#error your headers.
-#endif
-#if 3015008 < PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers. Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/port_undef.inc>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arena.h>
-#include <google/protobuf/arenastring.h>
-#include <google/protobuf/generated_message_table_driven.h>
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/metadata_lite.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/message.h>
-#include <google/protobuf/repeated_field.h> // IWYU pragma: export
-#include <google/protobuf/extension_set.h> // IWYU pragma: export
-#include <google/protobuf/generated_enum_reflection.h>
-#include <google/protobuf/unknown_field_set.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-#define PROTOBUF_INTERNAL_EXPORT_identity_2eproto
-PROTOBUF_NAMESPACE_OPEN
-namespace internal {
-class AnyMetadata;
-} // namespace internal
-PROTOBUF_NAMESPACE_CLOSE
-
-// Internal implementation detail -- do not use these members.
-struct TableStruct_identity_2eproto {
- static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
- 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[17]
- PROTOBUF_SECTION_VARIABLE(protodesc_cold);
- static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
- static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
- static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
-};
-extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_identity_2eproto;
-::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_identity_2eproto_metadata_getter(int index);
-namespace identity {
-class GetUserIDRequest;
-struct GetUserIDRequestDefaultTypeInternal;
-extern GetUserIDRequestDefaultTypeInternal _GetUserIDRequest_default_instance_;
-class GetUserIDResponse;
-struct GetUserIDResponseDefaultTypeInternal;
-extern GetUserIDResponseDefaultTypeInternal _GetUserIDResponse_default_instance_;
-class GetUserPublicKeyRequest;
-struct GetUserPublicKeyRequestDefaultTypeInternal;
-extern GetUserPublicKeyRequestDefaultTypeInternal _GetUserPublicKeyRequest_default_instance_;
-class GetUserPublicKeyResponse;
-struct GetUserPublicKeyResponseDefaultTypeInternal;
-extern GetUserPublicKeyResponseDefaultTypeInternal _GetUserPublicKeyResponse_default_instance_;
-class LoginRequest;
-struct LoginRequestDefaultTypeInternal;
-extern LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
-class LoginResponse;
-struct LoginResponseDefaultTypeInternal;
-extern LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
-class PakeCredentialRequestAndUserID;
-struct PakeCredentialRequestAndUserIDDefaultTypeInternal;
-extern PakeCredentialRequestAndUserIDDefaultTypeInternal _PakeCredentialRequestAndUserID_default_instance_;
-class PakeLoginRequest;
-struct PakeLoginRequestDefaultTypeInternal;
-extern PakeLoginRequestDefaultTypeInternal _PakeLoginRequest_default_instance_;
-class PakeLoginResponse;
-struct PakeLoginResponseDefaultTypeInternal;
-extern PakeLoginResponseDefaultTypeInternal _PakeLoginResponse_default_instance_;
-class PakeRegistrationRequestAndUserID;
-struct PakeRegistrationRequestAndUserIDDefaultTypeInternal;
-extern PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
-class PakeRegistrationUploadAndCredentialRequest;
-struct PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal;
-extern PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal _PakeRegistrationUploadAndCredentialRequest_default_instance_;
-class RegistrationRequest;
-struct RegistrationRequestDefaultTypeInternal;
-extern RegistrationRequestDefaultTypeInternal _RegistrationRequest_default_instance_;
-class RegistrationResponse;
-struct RegistrationResponseDefaultTypeInternal;
-extern RegistrationResponseDefaultTypeInternal _RegistrationResponse_default_instance_;
-class VerifyUserTokenRequest;
-struct VerifyUserTokenRequestDefaultTypeInternal;
-extern VerifyUserTokenRequestDefaultTypeInternal _VerifyUserTokenRequest_default_instance_;
-class VerifyUserTokenResponse;
-struct VerifyUserTokenResponseDefaultTypeInternal;
-extern VerifyUserTokenResponseDefaultTypeInternal _VerifyUserTokenResponse_default_instance_;
-class WalletLoginRequest;
-struct WalletLoginRequestDefaultTypeInternal;
-extern WalletLoginRequestDefaultTypeInternal _WalletLoginRequest_default_instance_;
-class WalletLoginResponse;
-struct WalletLoginResponseDefaultTypeInternal;
-extern WalletLoginResponseDefaultTypeInternal _WalletLoginResponse_default_instance_;
-} // namespace identity
-PROTOBUF_NAMESPACE_OPEN
-template<> ::identity::GetUserIDRequest* Arena::CreateMaybeMessage<::identity::GetUserIDRequest>(Arena*);
-template<> ::identity::GetUserIDResponse* Arena::CreateMaybeMessage<::identity::GetUserIDResponse>(Arena*);
-template<> ::identity::GetUserPublicKeyRequest* Arena::CreateMaybeMessage<::identity::GetUserPublicKeyRequest>(Arena*);
-template<> ::identity::GetUserPublicKeyResponse* Arena::CreateMaybeMessage<::identity::GetUserPublicKeyResponse>(Arena*);
-template<> ::identity::LoginRequest* Arena::CreateMaybeMessage<::identity::LoginRequest>(Arena*);
-template<> ::identity::LoginResponse* Arena::CreateMaybeMessage<::identity::LoginResponse>(Arena*);
-template<> ::identity::PakeCredentialRequestAndUserID* Arena::CreateMaybeMessage<::identity::PakeCredentialRequestAndUserID>(Arena*);
-template<> ::identity::PakeLoginRequest* Arena::CreateMaybeMessage<::identity::PakeLoginRequest>(Arena*);
-template<> ::identity::PakeLoginResponse* Arena::CreateMaybeMessage<::identity::PakeLoginResponse>(Arena*);
-template<> ::identity::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage<::identity::PakeRegistrationRequestAndUserID>(Arena*);
-template<> ::identity::PakeRegistrationUploadAndCredentialRequest* Arena::CreateMaybeMessage<::identity::PakeRegistrationUploadAndCredentialRequest>(Arena*);
-template<> ::identity::RegistrationRequest* Arena::CreateMaybeMessage<::identity::RegistrationRequest>(Arena*);
-template<> ::identity::RegistrationResponse* Arena::CreateMaybeMessage<::identity::RegistrationResponse>(Arena*);
-template<> ::identity::VerifyUserTokenRequest* Arena::CreateMaybeMessage<::identity::VerifyUserTokenRequest>(Arena*);
-template<> ::identity::VerifyUserTokenResponse* Arena::CreateMaybeMessage<::identity::VerifyUserTokenResponse>(Arena*);
-template<> ::identity::WalletLoginRequest* Arena::CreateMaybeMessage<::identity::WalletLoginRequest>(Arena*);
-template<> ::identity::WalletLoginResponse* Arena::CreateMaybeMessage<::identity::WalletLoginResponse>(Arena*);
-PROTOBUF_NAMESPACE_CLOSE
-namespace identity {
-
-enum GetUserIDRequest_AuthType : int {
- GetUserIDRequest_AuthType_PASSWORD = 0,
- GetUserIDRequest_AuthType_WALLET = 1,
- GetUserIDRequest_AuthType_GetUserIDRequest_AuthType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
- GetUserIDRequest_AuthType_GetUserIDRequest_AuthType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
-};
-bool GetUserIDRequest_AuthType_IsValid(int value);
-constexpr GetUserIDRequest_AuthType GetUserIDRequest_AuthType_AuthType_MIN = GetUserIDRequest_AuthType_PASSWORD;
-constexpr GetUserIDRequest_AuthType GetUserIDRequest_AuthType_AuthType_MAX = GetUserIDRequest_AuthType_WALLET;
-constexpr int GetUserIDRequest_AuthType_AuthType_ARRAYSIZE = GetUserIDRequest_AuthType_AuthType_MAX + 1;
-
-const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GetUserIDRequest_AuthType_descriptor();
-template<typename T>
-inline const std::string& GetUserIDRequest_AuthType_Name(T enum_t_value) {
- static_assert(::std::is_same<T, GetUserIDRequest_AuthType>::value ||
- ::std::is_integral<T>::value,
- "Incorrect type passed to function GetUserIDRequest_AuthType_Name.");
- return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
- GetUserIDRequest_AuthType_descriptor(), enum_t_value);
-}
-inline bool GetUserIDRequest_AuthType_Parse(
- ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GetUserIDRequest_AuthType* value) {
- return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GetUserIDRequest_AuthType>(
- GetUserIDRequest_AuthType_descriptor(), name, value);
-}
-// ===================================================================
-
-class PakeRegistrationRequestAndUserID PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeRegistrationRequestAndUserID) */ {
- public:
- inline PakeRegistrationRequestAndUserID() : PakeRegistrationRequestAndUserID(nullptr) {}
- virtual ~PakeRegistrationRequestAndUserID();
- explicit constexpr PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- PakeRegistrationRequestAndUserID(const PakeRegistrationRequestAndUserID& from);
- PakeRegistrationRequestAndUserID(PakeRegistrationRequestAndUserID&& from) noexcept
- : PakeRegistrationRequestAndUserID() {
- *this = ::std::move(from);
- }
-
- inline PakeRegistrationRequestAndUserID& operator=(const PakeRegistrationRequestAndUserID& from) {
- CopyFrom(from);
- return *this;
- }
- inline PakeRegistrationRequestAndUserID& operator=(PakeRegistrationRequestAndUserID&& 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 PakeRegistrationRequestAndUserID& default_instance() {
- return *internal_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(PakeRegistrationRequestAndUserID& a, PakeRegistrationRequestAndUserID& b) {
- a.Swap(&b);
- }
- inline void Swap(PakeRegistrationRequestAndUserID* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(PakeRegistrationRequestAndUserID* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline PakeRegistrationRequestAndUserID* New() const final {
- return CreateMaybeMessage<PakeRegistrationRequestAndUserID>(nullptr);
- }
-
- 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 PakeRegistrationRequestAndUserID& from);
- void MergeFrom(const PakeRegistrationRequestAndUserID& 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(PakeRegistrationRequestAndUserID* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.PakeRegistrationRequestAndUserID";
- }
- protected:
- explicit PakeRegistrationRequestAndUserID(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 1,
- kDeviceIDFieldNumber = 2,
- kPakeRegistrationRequestFieldNumber = 3,
- kUsernameFieldNumber = 4,
- kUserPublicKeyFieldNumber = 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);
- private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
- public:
-
- // string deviceID = 2;
- void clear_deviceid();
- const std::string& deviceid() const;
- void set_deviceid(const std::string& value);
- void set_deviceid(std::string&& value);
- void set_deviceid(const char* value);
- void set_deviceid(const char* value, size_t size);
- std::string* mutable_deviceid();
- std::string* release_deviceid();
- void set_allocated_deviceid(std::string* deviceid);
- private:
- const std::string& _internal_deviceid() const;
- void _internal_set_deviceid(const std::string& value);
- std::string* _internal_mutable_deviceid();
- public:
-
- // bytes pakeRegistrationRequest = 3;
- 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_pakeregistrationrequest() const;
- void _internal_set_pakeregistrationrequest(const std::string& value);
- std::string* _internal_mutable_pakeregistrationrequest();
- public:
-
- // string username = 4;
- void clear_username();
- const std::string& username() const;
- void set_username(const std::string& value);
- void set_username(std::string&& value);
- void set_username(const char* value);
- void set_username(const char* value, size_t size);
- std::string* mutable_username();
- std::string* release_username();
- void set_allocated_username(std::string* username);
- private:
- const std::string& _internal_username() const;
- void _internal_set_username(const std::string& value);
- std::string* _internal_mutable_username();
- public:
-
- // string userPublicKey = 5;
- void clear_userpublickey();
- const std::string& userpublickey() const;
- void set_userpublickey(const std::string& value);
- void set_userpublickey(std::string&& value);
- void set_userpublickey(const char* value);
- void set_userpublickey(const char* value, size_t size);
- std::string* mutable_userpublickey();
- std::string* release_userpublickey();
- void set_allocated_userpublickey(std::string* userpublickey);
- private:
- const std::string& _internal_userpublickey() const;
- void _internal_set_userpublickey(const std::string& value);
- std::string* _internal_mutable_userpublickey();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.PakeRegistrationRequestAndUserID)
- 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 deviceid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationrequest_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userpublickey_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PakeCredentialRequestAndUserID PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeCredentialRequestAndUserID) */ {
- public:
- inline PakeCredentialRequestAndUserID() : PakeCredentialRequestAndUserID(nullptr) {}
- virtual ~PakeCredentialRequestAndUserID();
- explicit constexpr PakeCredentialRequestAndUserID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- PakeCredentialRequestAndUserID(const PakeCredentialRequestAndUserID& from);
- PakeCredentialRequestAndUserID(PakeCredentialRequestAndUserID&& from) noexcept
- : PakeCredentialRequestAndUserID() {
- *this = ::std::move(from);
- }
-
- inline PakeCredentialRequestAndUserID& operator=(const PakeCredentialRequestAndUserID& from) {
- CopyFrom(from);
- return *this;
- }
- inline PakeCredentialRequestAndUserID& operator=(PakeCredentialRequestAndUserID&& 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 PakeCredentialRequestAndUserID& default_instance() {
- return *internal_default_instance();
- }
- static inline const PakeCredentialRequestAndUserID* internal_default_instance() {
- return reinterpret_cast<const PakeCredentialRequestAndUserID*>(
- &_PakeCredentialRequestAndUserID_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 1;
-
- friend void swap(PakeCredentialRequestAndUserID& a, PakeCredentialRequestAndUserID& b) {
- a.Swap(&b);
- }
- inline void Swap(PakeCredentialRequestAndUserID* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(PakeCredentialRequestAndUserID* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline PakeCredentialRequestAndUserID* New() const final {
- return CreateMaybeMessage<PakeCredentialRequestAndUserID>(nullptr);
- }
-
- PakeCredentialRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PakeCredentialRequestAndUserID>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PakeCredentialRequestAndUserID& from);
- void MergeFrom(const PakeCredentialRequestAndUserID& 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(PakeCredentialRequestAndUserID* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.PakeCredentialRequestAndUserID";
- }
- protected:
- explicit PakeCredentialRequestAndUserID(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 1,
- kDeviceIDFieldNumber = 2,
- kPakeCredentialRequestFieldNumber = 3,
- kUserPublicKeyFieldNumber = 4,
- };
- // string userID = 1;
- void clear_userid();
- const std::string& userid() const;
- void set_userid(const std::string& value);
- void set_userid(std::string&& value);
- void set_userid(const char* value);
- void set_userid(const char* value, size_t size);
- std::string* mutable_userid();
- std::string* release_userid();
- void set_allocated_userid(std::string* userid);
- private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
- public:
-
- // string deviceID = 2;
- void clear_deviceid();
- const std::string& deviceid() const;
- void set_deviceid(const std::string& value);
- void set_deviceid(std::string&& value);
- void set_deviceid(const char* value);
- void set_deviceid(const char* value, size_t size);
- std::string* mutable_deviceid();
- std::string* release_deviceid();
- void set_allocated_deviceid(std::string* deviceid);
- private:
- const std::string& _internal_deviceid() const;
- void _internal_set_deviceid(const std::string& value);
- std::string* _internal_mutable_deviceid();
- public:
-
- // bytes pakeCredentialRequest = 3;
- 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:
-
- // string userPublicKey = 4;
- void clear_userpublickey();
- const std::string& userpublickey() const;
- void set_userpublickey(const std::string& value);
- void set_userpublickey(std::string&& value);
- void set_userpublickey(const char* value);
- void set_userpublickey(const char* value, size_t size);
- std::string* mutable_userpublickey();
- std::string* release_userpublickey();
- void set_allocated_userpublickey(std::string* userpublickey);
- private:
- const std::string& _internal_userpublickey() const;
- void _internal_set_userpublickey(const std::string& value);
- std::string* _internal_mutable_userpublickey();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.PakeCredentialRequestAndUserID)
- 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 deviceid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userpublickey_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PakeLoginRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeLoginRequest) */ {
- public:
- inline PakeLoginRequest() : PakeLoginRequest(nullptr) {}
- virtual ~PakeLoginRequest();
- explicit constexpr PakeLoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- PakeLoginRequest(const PakeLoginRequest& from);
- PakeLoginRequest(PakeLoginRequest&& from) noexcept
- : PakeLoginRequest() {
- *this = ::std::move(from);
- }
-
- inline PakeLoginRequest& operator=(const PakeLoginRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline PakeLoginRequest& operator=(PakeLoginRequest&& 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 PakeLoginRequest& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeCredentialRequestAndUserID = 1,
- kPakeCredentialFinalization = 2,
- DATA_NOT_SET = 0,
- };
-
- static inline const PakeLoginRequest* internal_default_instance() {
- return reinterpret_cast<const PakeLoginRequest*>(
- &_PakeLoginRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 2;
-
- friend void swap(PakeLoginRequest& a, PakeLoginRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(PakeLoginRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(PakeLoginRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline PakeLoginRequest* New() const final {
- return CreateMaybeMessage<PakeLoginRequest>(nullptr);
- }
-
- PakeLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PakeLoginRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PakeLoginRequest& from);
- void MergeFrom(const PakeLoginRequest& 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(PakeLoginRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.PakeLoginRequest";
- }
- protected:
- explicit PakeLoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeCredentialRequestAndUserIDFieldNumber = 1,
- kPakeCredentialFinalizationFieldNumber = 2,
- };
- // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
- bool has_pakecredentialrequestanduserid() const;
- private:
- bool _internal_has_pakecredentialrequestanduserid() const;
- public:
- void clear_pakecredentialrequestanduserid();
- const ::identity::PakeCredentialRequestAndUserID& pakecredentialrequestanduserid() const;
- ::identity::PakeCredentialRequestAndUserID* release_pakecredentialrequestanduserid();
- ::identity::PakeCredentialRequestAndUserID* mutable_pakecredentialrequestanduserid();
- void set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid);
- private:
- const ::identity::PakeCredentialRequestAndUserID& _internal_pakecredentialrequestanduserid() const;
- ::identity::PakeCredentialRequestAndUserID* _internal_mutable_pakecredentialrequestanduserid();
- public:
- void unsafe_arena_set_allocated_pakecredentialrequestanduserid(
- ::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid);
- ::identity::PakeCredentialRequestAndUserID* unsafe_arena_release_pakecredentialrequestanduserid();
-
- // bytes pakeCredentialFinalization = 2;
- 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:
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.PakeLoginRequest)
- private:
- class _Internal;
- void set_has_pakecredentialrequestanduserid();
- void set_has_pakecredentialfinalization();
-
- 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_;
- ::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PakeLoginResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeLoginResponse) */ {
- public:
- inline PakeLoginResponse() : PakeLoginResponse(nullptr) {}
- virtual ~PakeLoginResponse();
- explicit constexpr PakeLoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- PakeLoginResponse(const PakeLoginResponse& from);
- PakeLoginResponse(PakeLoginResponse&& from) noexcept
- : PakeLoginResponse() {
- *this = ::std::move(from);
- }
-
- inline PakeLoginResponse& operator=(const PakeLoginResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline PakeLoginResponse& operator=(PakeLoginResponse&& 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 PakeLoginResponse& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeCredentialResponse = 1,
- kAccessToken = 2,
- DATA_NOT_SET = 0,
- };
-
- static inline const PakeLoginResponse* internal_default_instance() {
- return reinterpret_cast<const PakeLoginResponse*>(
- &_PakeLoginResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 3;
-
- friend void swap(PakeLoginResponse& a, PakeLoginResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(PakeLoginResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(PakeLoginResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline PakeLoginResponse* New() const final {
- return CreateMaybeMessage<PakeLoginResponse>(nullptr);
- }
-
- PakeLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PakeLoginResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PakeLoginResponse& from);
- void MergeFrom(const PakeLoginResponse& 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(PakeLoginResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.PakeLoginResponse";
- }
- protected:
- explicit PakeLoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeCredentialResponseFieldNumber = 1,
- kAccessTokenFieldNumber = 2,
- };
- // bytes pakeCredentialResponse = 1;
- 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:
-
- // string accessToken = 2;
- bool has_accesstoken() const;
- private:
- bool _internal_has_accesstoken() const;
- public:
- void clear_accesstoken();
- const std::string& accesstoken() const;
- void set_accesstoken(const std::string& value);
- void set_accesstoken(std::string&& value);
- void set_accesstoken(const char* value);
- void set_accesstoken(const char* value, size_t size);
- std::string* mutable_accesstoken();
- std::string* release_accesstoken();
- void set_allocated_accesstoken(std::string* accesstoken);
- private:
- const std::string& _internal_accesstoken() const;
- void _internal_set_accesstoken(const std::string& value);
- std::string* _internal_mutable_accesstoken();
- public:
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.PakeLoginResponse)
- private:
- class _Internal;
- void set_has_pakecredentialresponse();
- void set_has_accesstoken();
-
- 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 pakecredentialresponse_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class PakeRegistrationUploadAndCredentialRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.PakeRegistrationUploadAndCredentialRequest) */ {
- public:
- inline PakeRegistrationUploadAndCredentialRequest() : PakeRegistrationUploadAndCredentialRequest(nullptr) {}
- virtual ~PakeRegistrationUploadAndCredentialRequest();
- explicit constexpr PakeRegistrationUploadAndCredentialRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- PakeRegistrationUploadAndCredentialRequest(const PakeRegistrationUploadAndCredentialRequest& from);
- PakeRegistrationUploadAndCredentialRequest(PakeRegistrationUploadAndCredentialRequest&& from) noexcept
- : PakeRegistrationUploadAndCredentialRequest() {
- *this = ::std::move(from);
- }
-
- inline PakeRegistrationUploadAndCredentialRequest& operator=(const PakeRegistrationUploadAndCredentialRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline PakeRegistrationUploadAndCredentialRequest& operator=(PakeRegistrationUploadAndCredentialRequest&& 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 PakeRegistrationUploadAndCredentialRequest& default_instance() {
- return *internal_default_instance();
- }
- static inline const PakeRegistrationUploadAndCredentialRequest* internal_default_instance() {
- return reinterpret_cast<const PakeRegistrationUploadAndCredentialRequest*>(
- &_PakeRegistrationUploadAndCredentialRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 4;
-
- friend void swap(PakeRegistrationUploadAndCredentialRequest& a, PakeRegistrationUploadAndCredentialRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(PakeRegistrationUploadAndCredentialRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(PakeRegistrationUploadAndCredentialRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline PakeRegistrationUploadAndCredentialRequest* New() const final {
- return CreateMaybeMessage<PakeRegistrationUploadAndCredentialRequest>(nullptr);
- }
-
- PakeRegistrationUploadAndCredentialRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<PakeRegistrationUploadAndCredentialRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const PakeRegistrationUploadAndCredentialRequest& from);
- void MergeFrom(const PakeRegistrationUploadAndCredentialRequest& 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(PakeRegistrationUploadAndCredentialRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.PakeRegistrationUploadAndCredentialRequest";
- }
- protected:
- explicit PakeRegistrationUploadAndCredentialRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeRegistrationUploadFieldNumber = 1,
- kPakeCredentialRequestFieldNumber = 2,
- };
- // bytes pakeRegistrationUpload = 1;
- 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_pakeregistrationupload() const;
- void _internal_set_pakeregistrationupload(const std::string& value);
- std::string* _internal_mutable_pakeregistrationupload();
- public:
-
- // bytes pakeCredentialRequest = 2;
- 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:
-
- // @@protoc_insertion_point(class_scope:identity.PakeRegistrationUploadAndCredentialRequest)
- private:
- class _Internal;
-
- template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
- typedef void InternalArenaConstructable_;
- typedef void DestructorSkippable_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakeregistrationupload_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialrequest_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class WalletLoginRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.WalletLoginRequest) */ {
- public:
- inline WalletLoginRequest() : WalletLoginRequest(nullptr) {}
- virtual ~WalletLoginRequest();
- explicit constexpr WalletLoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- WalletLoginRequest(const WalletLoginRequest& from);
- WalletLoginRequest(WalletLoginRequest&& from) noexcept
- : WalletLoginRequest() {
- *this = ::std::move(from);
- }
-
- inline WalletLoginRequest& operator=(const WalletLoginRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline WalletLoginRequest& operator=(WalletLoginRequest&& 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 WalletLoginRequest& default_instance() {
- return *internal_default_instance();
- }
- static inline const WalletLoginRequest* internal_default_instance() {
- return reinterpret_cast<const WalletLoginRequest*>(
- &_WalletLoginRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 5;
-
- friend void swap(WalletLoginRequest& a, WalletLoginRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(WalletLoginRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(WalletLoginRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline WalletLoginRequest* New() const final {
- return CreateMaybeMessage<WalletLoginRequest>(nullptr);
- }
-
- WalletLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<WalletLoginRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const WalletLoginRequest& from);
- void MergeFrom(const WalletLoginRequest& 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(WalletLoginRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.WalletLoginRequest";
- }
- protected:
- explicit WalletLoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 1,
- kDeviceIDFieldNumber = 2,
- kSiweMessageFieldNumber = 3,
- kSiweSignatureFieldNumber = 4,
- kUserPublicKeyFieldNumber = 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);
- private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
- public:
-
- // string deviceID = 2;
- void clear_deviceid();
- const std::string& deviceid() const;
- void set_deviceid(const std::string& value);
- void set_deviceid(std::string&& value);
- void set_deviceid(const char* value);
- void set_deviceid(const char* value, size_t size);
- std::string* mutable_deviceid();
- std::string* release_deviceid();
- void set_allocated_deviceid(std::string* deviceid);
- private:
- const std::string& _internal_deviceid() const;
- void _internal_set_deviceid(const std::string& value);
- std::string* _internal_mutable_deviceid();
- public:
-
- // string siweMessage = 3;
- void clear_siwemessage();
- const std::string& siwemessage() const;
- void set_siwemessage(const std::string& value);
- void set_siwemessage(std::string&& value);
- void set_siwemessage(const char* value);
- void set_siwemessage(const char* value, size_t size);
- std::string* mutable_siwemessage();
- std::string* release_siwemessage();
- void set_allocated_siwemessage(std::string* siwemessage);
- private:
- const std::string& _internal_siwemessage() const;
- void _internal_set_siwemessage(const std::string& value);
- std::string* _internal_mutable_siwemessage();
- public:
-
- // bytes siweSignature = 4;
- void clear_siwesignature();
- const std::string& siwesignature() const;
- void set_siwesignature(const std::string& value);
- void set_siwesignature(std::string&& value);
- void set_siwesignature(const char* value);
- void set_siwesignature(const void* value, size_t size);
- std::string* mutable_siwesignature();
- std::string* release_siwesignature();
- void set_allocated_siwesignature(std::string* siwesignature);
- private:
- const std::string& _internal_siwesignature() const;
- void _internal_set_siwesignature(const std::string& value);
- std::string* _internal_mutable_siwesignature();
- public:
-
- // string userPublicKey = 5;
- void clear_userpublickey();
- const std::string& userpublickey() const;
- void set_userpublickey(const std::string& value);
- void set_userpublickey(std::string&& value);
- void set_userpublickey(const char* value);
- void set_userpublickey(const char* value, size_t size);
- std::string* mutable_userpublickey();
- std::string* release_userpublickey();
- void set_allocated_userpublickey(std::string* userpublickey);
- private:
- const std::string& _internal_userpublickey() const;
- void _internal_set_userpublickey(const std::string& value);
- std::string* _internal_mutable_userpublickey();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.WalletLoginRequest)
- 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 deviceid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr siwemessage_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr siwesignature_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userpublickey_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class WalletLoginResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.WalletLoginResponse) */ {
- public:
- inline WalletLoginResponse() : WalletLoginResponse(nullptr) {}
- virtual ~WalletLoginResponse();
- explicit constexpr WalletLoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- WalletLoginResponse(const WalletLoginResponse& from);
- WalletLoginResponse(WalletLoginResponse&& from) noexcept
- : WalletLoginResponse() {
- *this = ::std::move(from);
- }
-
- inline WalletLoginResponse& operator=(const WalletLoginResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline WalletLoginResponse& operator=(WalletLoginResponse&& 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 WalletLoginResponse& default_instance() {
- return *internal_default_instance();
- }
- static inline const WalletLoginResponse* internal_default_instance() {
- return reinterpret_cast<const WalletLoginResponse*>(
- &_WalletLoginResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 6;
-
- friend void swap(WalletLoginResponse& a, WalletLoginResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(WalletLoginResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(WalletLoginResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline WalletLoginResponse* New() const final {
- return CreateMaybeMessage<WalletLoginResponse>(nullptr);
- }
-
- WalletLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<WalletLoginResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const WalletLoginResponse& from);
- void MergeFrom(const WalletLoginResponse& 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(WalletLoginResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.WalletLoginResponse";
- }
- protected:
- explicit WalletLoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kAccessTokenFieldNumber = 1,
- };
- // string accessToken = 1;
- void clear_accesstoken();
- const std::string& accesstoken() const;
- void set_accesstoken(const std::string& value);
- void set_accesstoken(std::string&& value);
- void set_accesstoken(const char* value);
- void set_accesstoken(const char* value, size_t size);
- std::string* mutable_accesstoken();
- std::string* release_accesstoken();
- void set_allocated_accesstoken(std::string* accesstoken);
- private:
- const std::string& _internal_accesstoken() const;
- void _internal_set_accesstoken(const std::string& value);
- std::string* _internal_mutable_accesstoken();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.WalletLoginResponse)
- private:
- class _Internal;
-
- template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
- typedef void InternalArenaConstructable_;
- typedef void DestructorSkippable_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class RegistrationRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.RegistrationRequest) */ {
- public:
- inline RegistrationRequest() : RegistrationRequest(nullptr) {}
- virtual ~RegistrationRequest();
- explicit constexpr RegistrationRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- RegistrationRequest(const RegistrationRequest& from);
- RegistrationRequest(RegistrationRequest&& from) noexcept
- : RegistrationRequest() {
- *this = ::std::move(from);
- }
-
- inline RegistrationRequest& operator=(const RegistrationRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline RegistrationRequest& operator=(RegistrationRequest&& 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 RegistrationRequest& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeRegistrationRequestAndUserID = 1,
- kPakeRegistrationUploadAndCredentialRequest = 2,
- kPakeCredentialFinalization = 3,
- DATA_NOT_SET = 0,
- };
-
- static inline const RegistrationRequest* internal_default_instance() {
- return reinterpret_cast<const RegistrationRequest*>(
- &_RegistrationRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 7;
-
- friend void swap(RegistrationRequest& a, RegistrationRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(RegistrationRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(RegistrationRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline RegistrationRequest* New() const final {
- return CreateMaybeMessage<RegistrationRequest>(nullptr);
- }
-
- RegistrationRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<RegistrationRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const RegistrationRequest& from);
- void MergeFrom(const RegistrationRequest& 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(RegistrationRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.RegistrationRequest";
- }
- protected:
- explicit RegistrationRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeRegistrationRequestAndUserIDFieldNumber = 1,
- kPakeRegistrationUploadAndCredentialRequestFieldNumber = 2,
- kPakeCredentialFinalizationFieldNumber = 3,
- };
- // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
- bool has_pakeregistrationrequestanduserid() const;
- private:
- bool _internal_has_pakeregistrationrequestanduserid() const;
- public:
- void clear_pakeregistrationrequestanduserid();
- const ::identity::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid() const;
- ::identity::PakeRegistrationRequestAndUserID* release_pakeregistrationrequestanduserid();
- ::identity::PakeRegistrationRequestAndUserID* mutable_pakeregistrationrequestanduserid();
- void set_allocated_pakeregistrationrequestanduserid(::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
- private:
- const ::identity::PakeRegistrationRequestAndUserID& _internal_pakeregistrationrequestanduserid() const;
- ::identity::PakeRegistrationRequestAndUserID* _internal_mutable_pakeregistrationrequestanduserid();
- public:
- void unsafe_arena_set_allocated_pakeregistrationrequestanduserid(
- ::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid);
- ::identity::PakeRegistrationRequestAndUserID* unsafe_arena_release_pakeregistrationrequestanduserid();
-
- // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
- bool has_pakeregistrationuploadandcredentialrequest() const;
- private:
- bool _internal_has_pakeregistrationuploadandcredentialrequest() const;
- public:
- void clear_pakeregistrationuploadandcredentialrequest();
- const ::identity::PakeRegistrationUploadAndCredentialRequest& pakeregistrationuploadandcredentialrequest() const;
- ::identity::PakeRegistrationUploadAndCredentialRequest* release_pakeregistrationuploadandcredentialrequest();
- ::identity::PakeRegistrationUploadAndCredentialRequest* mutable_pakeregistrationuploadandcredentialrequest();
- void set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest);
- private:
- const ::identity::PakeRegistrationUploadAndCredentialRequest& _internal_pakeregistrationuploadandcredentialrequest() const;
- ::identity::PakeRegistrationUploadAndCredentialRequest* _internal_mutable_pakeregistrationuploadandcredentialrequest();
- public:
- void unsafe_arena_set_allocated_pakeregistrationuploadandcredentialrequest(
- ::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest);
- ::identity::PakeRegistrationUploadAndCredentialRequest* unsafe_arena_release_pakeregistrationuploadandcredentialrequest();
-
- // bytes pakeCredentialFinalization = 3;
- 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:
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.RegistrationRequest)
- private:
- class _Internal;
- void set_has_pakeregistrationrequestanduserid();
- void set_has_pakeregistrationuploadandcredentialrequest();
- void set_has_pakecredentialfinalization();
-
- 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_;
- ::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid_;
- ::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pakecredentialfinalization_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class RegistrationResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.RegistrationResponse) */ {
- public:
- inline RegistrationResponse() : RegistrationResponse(nullptr) {}
- virtual ~RegistrationResponse();
- explicit constexpr RegistrationResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- RegistrationResponse(const RegistrationResponse& from);
- RegistrationResponse(RegistrationResponse&& from) noexcept
- : RegistrationResponse() {
- *this = ::std::move(from);
- }
-
- inline RegistrationResponse& operator=(const RegistrationResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline RegistrationResponse& operator=(RegistrationResponse&& 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 RegistrationResponse& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeRegistrationResponse = 1,
- kPakeLoginResponse = 2,
- DATA_NOT_SET = 0,
- };
-
- static inline const RegistrationResponse* internal_default_instance() {
- return reinterpret_cast<const RegistrationResponse*>(
- &_RegistrationResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 8;
-
- friend void swap(RegistrationResponse& a, RegistrationResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(RegistrationResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(RegistrationResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline RegistrationResponse* New() const final {
- return CreateMaybeMessage<RegistrationResponse>(nullptr);
- }
-
- RegistrationResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<RegistrationResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const RegistrationResponse& from);
- void MergeFrom(const RegistrationResponse& 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(RegistrationResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.RegistrationResponse";
- }
- protected:
- explicit RegistrationResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeRegistrationResponseFieldNumber = 1,
- kPakeLoginResponseFieldNumber = 2,
- };
- // bytes pakeRegistrationResponse = 1;
- bool has_pakeregistrationresponse() const;
- private:
- bool _internal_has_pakeregistrationresponse() const;
- public:
- 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_pakeregistrationresponse() const;
- void _internal_set_pakeregistrationresponse(const std::string& value);
- std::string* _internal_mutable_pakeregistrationresponse();
- public:
-
- // .identity.PakeLoginResponse pakeLoginResponse = 2;
- bool has_pakeloginresponse() const;
- private:
- bool _internal_has_pakeloginresponse() const;
- public:
- void clear_pakeloginresponse();
- const ::identity::PakeLoginResponse& pakeloginresponse() const;
- ::identity::PakeLoginResponse* release_pakeloginresponse();
- ::identity::PakeLoginResponse* mutable_pakeloginresponse();
- void set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse);
- private:
- const ::identity::PakeLoginResponse& _internal_pakeloginresponse() const;
- ::identity::PakeLoginResponse* _internal_mutable_pakeloginresponse();
- public:
- void unsafe_arena_set_allocated_pakeloginresponse(
- ::identity::PakeLoginResponse* pakeloginresponse);
- ::identity::PakeLoginResponse* unsafe_arena_release_pakeloginresponse();
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.RegistrationResponse)
- private:
- class _Internal;
- void set_has_pakeregistrationresponse();
- void set_has_pakeloginresponse();
-
- 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 pakeregistrationresponse_;
- ::identity::PakeLoginResponse* pakeloginresponse_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class LoginRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.LoginRequest) */ {
- public:
- inline LoginRequest() : LoginRequest(nullptr) {}
- virtual ~LoginRequest();
- explicit constexpr LoginRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- LoginRequest(const LoginRequest& from);
- LoginRequest(LoginRequest&& from) noexcept
- : LoginRequest() {
- *this = ::std::move(from);
- }
-
- inline LoginRequest& operator=(const LoginRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline LoginRequest& operator=(LoginRequest&& 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 LoginRequest& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeLoginRequest = 1,
- kWalletLoginRequest = 2,
- DATA_NOT_SET = 0,
- };
-
- static inline const LoginRequest* internal_default_instance() {
- return reinterpret_cast<const LoginRequest*>(
- &_LoginRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 9;
-
- friend void swap(LoginRequest& a, LoginRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(LoginRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(LoginRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline LoginRequest* New() const final {
- return CreateMaybeMessage<LoginRequest>(nullptr);
- }
-
- LoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<LoginRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const LoginRequest& from);
- void MergeFrom(const LoginRequest& 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(LoginRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.LoginRequest";
- }
- protected:
- explicit LoginRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeLoginRequestFieldNumber = 1,
- kWalletLoginRequestFieldNumber = 2,
- };
- // .identity.PakeLoginRequest pakeLoginRequest = 1;
- bool has_pakeloginrequest() const;
- private:
- bool _internal_has_pakeloginrequest() const;
- public:
- void clear_pakeloginrequest();
- const ::identity::PakeLoginRequest& pakeloginrequest() const;
- ::identity::PakeLoginRequest* release_pakeloginrequest();
- ::identity::PakeLoginRequest* mutable_pakeloginrequest();
- void set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest);
- private:
- const ::identity::PakeLoginRequest& _internal_pakeloginrequest() const;
- ::identity::PakeLoginRequest* _internal_mutable_pakeloginrequest();
- public:
- void unsafe_arena_set_allocated_pakeloginrequest(
- ::identity::PakeLoginRequest* pakeloginrequest);
- ::identity::PakeLoginRequest* unsafe_arena_release_pakeloginrequest();
-
- // .identity.WalletLoginRequest walletLoginRequest = 2;
- bool has_walletloginrequest() const;
- private:
- bool _internal_has_walletloginrequest() const;
- public:
- void clear_walletloginrequest();
- const ::identity::WalletLoginRequest& walletloginrequest() const;
- ::identity::WalletLoginRequest* release_walletloginrequest();
- ::identity::WalletLoginRequest* mutable_walletloginrequest();
- void set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest);
- private:
- const ::identity::WalletLoginRequest& _internal_walletloginrequest() const;
- ::identity::WalletLoginRequest* _internal_mutable_walletloginrequest();
- public:
- void unsafe_arena_set_allocated_walletloginrequest(
- ::identity::WalletLoginRequest* walletloginrequest);
- ::identity::WalletLoginRequest* unsafe_arena_release_walletloginrequest();
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.LoginRequest)
- private:
- class _Internal;
- void set_has_pakeloginrequest();
- void set_has_walletloginrequest();
-
- 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_;
- ::identity::PakeLoginRequest* pakeloginrequest_;
- ::identity::WalletLoginRequest* walletloginrequest_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class LoginResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.LoginResponse) */ {
- public:
- inline LoginResponse() : LoginResponse(nullptr) {}
- virtual ~LoginResponse();
- explicit constexpr LoginResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- LoginResponse(const LoginResponse& from);
- LoginResponse(LoginResponse&& from) noexcept
- : LoginResponse() {
- *this = ::std::move(from);
- }
-
- inline LoginResponse& operator=(const LoginResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline LoginResponse& operator=(LoginResponse&& 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 LoginResponse& default_instance() {
- return *internal_default_instance();
- }
- enum DataCase {
- kPakeLoginResponse = 1,
- kWalletLoginResponse = 2,
- DATA_NOT_SET = 0,
- };
-
- static inline const LoginResponse* internal_default_instance() {
- return reinterpret_cast<const LoginResponse*>(
- &_LoginResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 10;
-
- friend void swap(LoginResponse& a, LoginResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(LoginResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(LoginResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline LoginResponse* New() const final {
- return CreateMaybeMessage<LoginResponse>(nullptr);
- }
-
- LoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<LoginResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const LoginResponse& from);
- void MergeFrom(const LoginResponse& 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(LoginResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.LoginResponse";
- }
- protected:
- explicit LoginResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPakeLoginResponseFieldNumber = 1,
- kWalletLoginResponseFieldNumber = 2,
- };
- // .identity.PakeLoginResponse pakeLoginResponse = 1;
- bool has_pakeloginresponse() const;
- private:
- bool _internal_has_pakeloginresponse() const;
- public:
- void clear_pakeloginresponse();
- const ::identity::PakeLoginResponse& pakeloginresponse() const;
- ::identity::PakeLoginResponse* release_pakeloginresponse();
- ::identity::PakeLoginResponse* mutable_pakeloginresponse();
- void set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse);
- private:
- const ::identity::PakeLoginResponse& _internal_pakeloginresponse() const;
- ::identity::PakeLoginResponse* _internal_mutable_pakeloginresponse();
- public:
- void unsafe_arena_set_allocated_pakeloginresponse(
- ::identity::PakeLoginResponse* pakeloginresponse);
- ::identity::PakeLoginResponse* unsafe_arena_release_pakeloginresponse();
-
- // .identity.WalletLoginResponse walletLoginResponse = 2;
- bool has_walletloginresponse() const;
- private:
- bool _internal_has_walletloginresponse() const;
- public:
- void clear_walletloginresponse();
- const ::identity::WalletLoginResponse& walletloginresponse() const;
- ::identity::WalletLoginResponse* release_walletloginresponse();
- ::identity::WalletLoginResponse* mutable_walletloginresponse();
- void set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse);
- private:
- const ::identity::WalletLoginResponse& _internal_walletloginresponse() const;
- ::identity::WalletLoginResponse* _internal_mutable_walletloginresponse();
- public:
- void unsafe_arena_set_allocated_walletloginresponse(
- ::identity::WalletLoginResponse* walletloginresponse);
- ::identity::WalletLoginResponse* unsafe_arena_release_walletloginresponse();
-
- void clear_data();
- DataCase data_case() const;
- // @@protoc_insertion_point(class_scope:identity.LoginResponse)
- private:
- class _Internal;
- void set_has_pakeloginresponse();
- void set_has_walletloginresponse();
-
- 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_;
- ::identity::PakeLoginResponse* pakeloginresponse_;
- ::identity::WalletLoginResponse* walletloginresponse_;
- } data_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
-
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class VerifyUserTokenRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.VerifyUserTokenRequest) */ {
- public:
- inline VerifyUserTokenRequest() : VerifyUserTokenRequest(nullptr) {}
- virtual ~VerifyUserTokenRequest();
- explicit constexpr VerifyUserTokenRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- VerifyUserTokenRequest(const VerifyUserTokenRequest& from);
- VerifyUserTokenRequest(VerifyUserTokenRequest&& from) noexcept
- : VerifyUserTokenRequest() {
- *this = ::std::move(from);
- }
-
- inline VerifyUserTokenRequest& operator=(const VerifyUserTokenRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline VerifyUserTokenRequest& operator=(VerifyUserTokenRequest&& 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 VerifyUserTokenRequest& default_instance() {
- return *internal_default_instance();
- }
- static inline const VerifyUserTokenRequest* internal_default_instance() {
- return reinterpret_cast<const VerifyUserTokenRequest*>(
- &_VerifyUserTokenRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 11;
-
- friend void swap(VerifyUserTokenRequest& a, VerifyUserTokenRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(VerifyUserTokenRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(VerifyUserTokenRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline VerifyUserTokenRequest* New() const final {
- return CreateMaybeMessage<VerifyUserTokenRequest>(nullptr);
- }
-
- VerifyUserTokenRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<VerifyUserTokenRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const VerifyUserTokenRequest& from);
- void MergeFrom(const VerifyUserTokenRequest& 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(VerifyUserTokenRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.VerifyUserTokenRequest";
- }
- protected:
- explicit VerifyUserTokenRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 1,
- kDeviceIDFieldNumber = 2,
- kAccessTokenFieldNumber = 3,
- };
- // string userID = 1;
- void clear_userid();
- const std::string& userid() const;
- void set_userid(const std::string& value);
- void set_userid(std::string&& value);
- void set_userid(const char* value);
- void set_userid(const char* value, size_t size);
- std::string* mutable_userid();
- std::string* release_userid();
- void set_allocated_userid(std::string* userid);
- private:
- const std::string& _internal_userid() const;
- void _internal_set_userid(const std::string& value);
- std::string* _internal_mutable_userid();
- public:
-
- // string deviceID = 2;
- void clear_deviceid();
- const std::string& deviceid() const;
- void set_deviceid(const std::string& value);
- void set_deviceid(std::string&& value);
- void set_deviceid(const char* value);
- void set_deviceid(const char* value, size_t size);
- std::string* mutable_deviceid();
- std::string* release_deviceid();
- void set_allocated_deviceid(std::string* deviceid);
- private:
- const std::string& _internal_deviceid() const;
- void _internal_set_deviceid(const std::string& value);
- std::string* _internal_mutable_deviceid();
- public:
-
- // string accessToken = 3;
- void clear_accesstoken();
- const std::string& accesstoken() const;
- void set_accesstoken(const std::string& value);
- void set_accesstoken(std::string&& value);
- void set_accesstoken(const char* value);
- void set_accesstoken(const char* value, size_t size);
- std::string* mutable_accesstoken();
- std::string* release_accesstoken();
- void set_allocated_accesstoken(std::string* accesstoken);
- private:
- const std::string& _internal_accesstoken() const;
- void _internal_set_accesstoken(const std::string& value);
- std::string* _internal_mutable_accesstoken();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.VerifyUserTokenRequest)
- 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 deviceid_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accesstoken_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class VerifyUserTokenResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.VerifyUserTokenResponse) */ {
- public:
- inline VerifyUserTokenResponse() : VerifyUserTokenResponse(nullptr) {}
- virtual ~VerifyUserTokenResponse();
- explicit constexpr VerifyUserTokenResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- VerifyUserTokenResponse(const VerifyUserTokenResponse& from);
- VerifyUserTokenResponse(VerifyUserTokenResponse&& from) noexcept
- : VerifyUserTokenResponse() {
- *this = ::std::move(from);
- }
-
- inline VerifyUserTokenResponse& operator=(const VerifyUserTokenResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline VerifyUserTokenResponse& operator=(VerifyUserTokenResponse&& 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 VerifyUserTokenResponse& default_instance() {
- return *internal_default_instance();
- }
- static inline const VerifyUserTokenResponse* internal_default_instance() {
- return reinterpret_cast<const VerifyUserTokenResponse*>(
- &_VerifyUserTokenResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 12;
-
- friend void swap(VerifyUserTokenResponse& a, VerifyUserTokenResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(VerifyUserTokenResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(VerifyUserTokenResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline VerifyUserTokenResponse* New() const final {
- return CreateMaybeMessage<VerifyUserTokenResponse>(nullptr);
- }
-
- VerifyUserTokenResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<VerifyUserTokenResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const VerifyUserTokenResponse& from);
- void MergeFrom(const VerifyUserTokenResponse& 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(VerifyUserTokenResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.VerifyUserTokenResponse";
- }
- protected:
- explicit VerifyUserTokenResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kTokenValidFieldNumber = 1,
- };
- // bool tokenValid = 1;
- void clear_tokenvalid();
- bool tokenvalid() const;
- void set_tokenvalid(bool value);
- private:
- bool _internal_tokenvalid() const;
- void _internal_set_tokenvalid(bool value);
- public:
-
- // @@protoc_insertion_point(class_scope:identity.VerifyUserTokenResponse)
- private:
- class _Internal;
-
- template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
- typedef void InternalArenaConstructable_;
- typedef void DestructorSkippable_;
- bool tokenvalid_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class GetUserIDRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.GetUserIDRequest) */ {
- public:
- inline GetUserIDRequest() : GetUserIDRequest(nullptr) {}
- virtual ~GetUserIDRequest();
- explicit constexpr GetUserIDRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- GetUserIDRequest(const GetUserIDRequest& from);
- GetUserIDRequest(GetUserIDRequest&& from) noexcept
- : GetUserIDRequest() {
- *this = ::std::move(from);
- }
-
- inline GetUserIDRequest& operator=(const GetUserIDRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline GetUserIDRequest& operator=(GetUserIDRequest&& 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 GetUserIDRequest& default_instance() {
- return *internal_default_instance();
- }
- static inline const GetUserIDRequest* internal_default_instance() {
- return reinterpret_cast<const GetUserIDRequest*>(
- &_GetUserIDRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 13;
-
- friend void swap(GetUserIDRequest& a, GetUserIDRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(GetUserIDRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(GetUserIDRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline GetUserIDRequest* New() const final {
- return CreateMaybeMessage<GetUserIDRequest>(nullptr);
- }
-
- GetUserIDRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<GetUserIDRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const GetUserIDRequest& from);
- void MergeFrom(const GetUserIDRequest& 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(GetUserIDRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.GetUserIDRequest";
- }
- protected:
- explicit GetUserIDRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- typedef GetUserIDRequest_AuthType AuthType;
- static constexpr AuthType PASSWORD =
- GetUserIDRequest_AuthType_PASSWORD;
- static constexpr AuthType WALLET =
- GetUserIDRequest_AuthType_WALLET;
- static inline bool AuthType_IsValid(int value) {
- return GetUserIDRequest_AuthType_IsValid(value);
- }
- static constexpr AuthType AuthType_MIN =
- GetUserIDRequest_AuthType_AuthType_MIN;
- static constexpr AuthType AuthType_MAX =
- GetUserIDRequest_AuthType_AuthType_MAX;
- static constexpr int AuthType_ARRAYSIZE =
- GetUserIDRequest_AuthType_AuthType_ARRAYSIZE;
- static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
- AuthType_descriptor() {
- return GetUserIDRequest_AuthType_descriptor();
- }
- template<typename T>
- static inline const std::string& AuthType_Name(T enum_t_value) {
- static_assert(::std::is_same<T, AuthType>::value ||
- ::std::is_integral<T>::value,
- "Incorrect type passed to function AuthType_Name.");
- return GetUserIDRequest_AuthType_Name(enum_t_value);
- }
- static inline bool AuthType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
- AuthType* value) {
- return GetUserIDRequest_AuthType_Parse(name, value);
- }
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserInfoFieldNumber = 2,
- kAuthTypeFieldNumber = 1,
- };
- // string userInfo = 2;
- void clear_userinfo();
- const std::string& userinfo() const;
- void set_userinfo(const std::string& value);
- void set_userinfo(std::string&& value);
- void set_userinfo(const char* value);
- void set_userinfo(const char* value, size_t size);
- std::string* mutable_userinfo();
- std::string* release_userinfo();
- void set_allocated_userinfo(std::string* userinfo);
- private:
- const std::string& _internal_userinfo() const;
- void _internal_set_userinfo(const std::string& value);
- std::string* _internal_mutable_userinfo();
- public:
-
- // .identity.GetUserIDRequest.AuthType authType = 1;
- void clear_authtype();
- ::identity::GetUserIDRequest_AuthType authtype() const;
- void set_authtype(::identity::GetUserIDRequest_AuthType value);
- private:
- ::identity::GetUserIDRequest_AuthType _internal_authtype() const;
- void _internal_set_authtype(::identity::GetUserIDRequest_AuthType value);
- public:
-
- // @@protoc_insertion_point(class_scope:identity.GetUserIDRequest)
- private:
- class _Internal;
-
- template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
- typedef void InternalArenaConstructable_;
- typedef void DestructorSkippable_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userinfo_;
- int authtype_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class GetUserIDResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.GetUserIDResponse) */ {
- public:
- inline GetUserIDResponse() : GetUserIDResponse(nullptr) {}
- virtual ~GetUserIDResponse();
- explicit constexpr GetUserIDResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- GetUserIDResponse(const GetUserIDResponse& from);
- GetUserIDResponse(GetUserIDResponse&& from) noexcept
- : GetUserIDResponse() {
- *this = ::std::move(from);
- }
-
- inline GetUserIDResponse& operator=(const GetUserIDResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline GetUserIDResponse& operator=(GetUserIDResponse&& 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 GetUserIDResponse& default_instance() {
- return *internal_default_instance();
- }
- static inline const GetUserIDResponse* internal_default_instance() {
- return reinterpret_cast<const GetUserIDResponse*>(
- &_GetUserIDResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 14;
-
- friend void swap(GetUserIDResponse& a, GetUserIDResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(GetUserIDResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(GetUserIDResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline GetUserIDResponse* New() const final {
- return CreateMaybeMessage<GetUserIDResponse>(nullptr);
- }
-
- GetUserIDResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<GetUserIDResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const GetUserIDResponse& from);
- void MergeFrom(const GetUserIDResponse& 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(GetUserIDResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.GetUserIDResponse";
- }
- protected:
- explicit GetUserIDResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 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:
-
- // @@protoc_insertion_point(class_scope:identity.GetUserIDResponse)
- 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_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class GetUserPublicKeyRequest PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.GetUserPublicKeyRequest) */ {
- public:
- inline GetUserPublicKeyRequest() : GetUserPublicKeyRequest(nullptr) {}
- virtual ~GetUserPublicKeyRequest();
- explicit constexpr GetUserPublicKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- GetUserPublicKeyRequest(const GetUserPublicKeyRequest& from);
- GetUserPublicKeyRequest(GetUserPublicKeyRequest&& from) noexcept
- : GetUserPublicKeyRequest() {
- *this = ::std::move(from);
- }
-
- inline GetUserPublicKeyRequest& operator=(const GetUserPublicKeyRequest& from) {
- CopyFrom(from);
- return *this;
- }
- inline GetUserPublicKeyRequest& operator=(GetUserPublicKeyRequest&& 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 GetUserPublicKeyRequest& default_instance() {
- return *internal_default_instance();
- }
- static inline const GetUserPublicKeyRequest* internal_default_instance() {
- return reinterpret_cast<const GetUserPublicKeyRequest*>(
- &_GetUserPublicKeyRequest_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 15;
-
- friend void swap(GetUserPublicKeyRequest& a, GetUserPublicKeyRequest& b) {
- a.Swap(&b);
- }
- inline void Swap(GetUserPublicKeyRequest* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(GetUserPublicKeyRequest* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline GetUserPublicKeyRequest* New() const final {
- return CreateMaybeMessage<GetUserPublicKeyRequest>(nullptr);
- }
-
- GetUserPublicKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<GetUserPublicKeyRequest>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const GetUserPublicKeyRequest& from);
- void MergeFrom(const GetUserPublicKeyRequest& 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(GetUserPublicKeyRequest* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.GetUserPublicKeyRequest";
- }
- protected:
- explicit GetUserPublicKeyRequest(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kUserIDFieldNumber = 1,
- kDeviceIDFieldNumber = 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 deviceID = 2;
- void clear_deviceid();
- const std::string& deviceid() const;
- void set_deviceid(const std::string& value);
- void set_deviceid(std::string&& value);
- void set_deviceid(const char* value);
- void set_deviceid(const char* value, size_t size);
- std::string* mutable_deviceid();
- std::string* release_deviceid();
- void set_allocated_deviceid(std::string* deviceid);
- private:
- const std::string& _internal_deviceid() const;
- void _internal_set_deviceid(const std::string& value);
- std::string* _internal_mutable_deviceid();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.GetUserPublicKeyRequest)
- 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 deviceid_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_2eproto;
-};
-// -------------------------------------------------------------------
-
-class GetUserPublicKeyResponse PROTOBUF_FINAL :
- public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:identity.GetUserPublicKeyResponse) */ {
- public:
- inline GetUserPublicKeyResponse() : GetUserPublicKeyResponse(nullptr) {}
- virtual ~GetUserPublicKeyResponse();
- explicit constexpr GetUserPublicKeyResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
-
- GetUserPublicKeyResponse(const GetUserPublicKeyResponse& from);
- GetUserPublicKeyResponse(GetUserPublicKeyResponse&& from) noexcept
- : GetUserPublicKeyResponse() {
- *this = ::std::move(from);
- }
-
- inline GetUserPublicKeyResponse& operator=(const GetUserPublicKeyResponse& from) {
- CopyFrom(from);
- return *this;
- }
- inline GetUserPublicKeyResponse& operator=(GetUserPublicKeyResponse&& 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 GetUserPublicKeyResponse& default_instance() {
- return *internal_default_instance();
- }
- static inline const GetUserPublicKeyResponse* internal_default_instance() {
- return reinterpret_cast<const GetUserPublicKeyResponse*>(
- &_GetUserPublicKeyResponse_default_instance_);
- }
- static constexpr int kIndexInFileMessages =
- 16;
-
- friend void swap(GetUserPublicKeyResponse& a, GetUserPublicKeyResponse& b) {
- a.Swap(&b);
- }
- inline void Swap(GetUserPublicKeyResponse* other) {
- if (other == this) return;
- if (GetArena() == other->GetArena()) {
- InternalSwap(other);
- } else {
- ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
- }
- }
- void UnsafeArenaSwap(GetUserPublicKeyResponse* other) {
- if (other == this) return;
- GOOGLE_DCHECK(GetArena() == other->GetArena());
- InternalSwap(other);
- }
-
- // implements Message ----------------------------------------------
-
- inline GetUserPublicKeyResponse* New() const final {
- return CreateMaybeMessage<GetUserPublicKeyResponse>(nullptr);
- }
-
- GetUserPublicKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
- return CreateMaybeMessage<GetUserPublicKeyResponse>(arena);
- }
- void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
- void CopyFrom(const GetUserPublicKeyResponse& from);
- void MergeFrom(const GetUserPublicKeyResponse& 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(GetUserPublicKeyResponse* other);
- friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
- static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
- return "identity.GetUserPublicKeyResponse";
- }
- protected:
- explicit GetUserPublicKeyResponse(::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_identity_2eproto_metadata_getter(kIndexInFileMessages);
- }
-
- public:
-
- // nested types ----------------------------------------------------
-
- // accessors -------------------------------------------------------
-
- enum : int {
- kPublicKeyFieldNumber = 1,
- };
- // string publicKey = 1;
- 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 char* value, size_t size);
- std::string* mutable_publickey();
- std::string* release_publickey();
- void set_allocated_publickey(std::string* publickey);
- private:
- const std::string& _internal_publickey() const;
- void _internal_set_publickey(const std::string& value);
- std::string* _internal_mutable_publickey();
- public:
-
- // @@protoc_insertion_point(class_scope:identity.GetUserPublicKeyResponse)
- private:
- class _Internal;
-
- template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
- typedef void InternalArenaConstructable_;
- typedef void DestructorSkippable_;
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_;
- mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
- friend struct ::TableStruct_identity_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:identity.PakeRegistrationRequestAndUserID.userID)
- return _internal_userid();
-}
-inline void PakeRegistrationRequestAndUserID::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.userID)
-}
-inline std::string* PakeRegistrationRequestAndUserID::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.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:identity.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:identity.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:identity.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:identity.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:identity.PakeRegistrationRequestAndUserID.userID)
-}
-
-// string deviceID = 2;
-inline void PakeRegistrationRequestAndUserID::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::deviceid() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.deviceID)
- return _internal_deviceid();
-}
-inline void PakeRegistrationRequestAndUserID::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.deviceID)
-}
-inline std::string* PakeRegistrationRequestAndUserID::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void PakeRegistrationRequestAndUserID::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.deviceID)
-}
-inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
-}
-inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
-}
-inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeRegistrationRequestAndUserID::release_deviceid() {
- // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::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:identity.PakeRegistrationRequestAndUserID.deviceID)
-}
-
-// bytes pakeRegistrationRequest = 3;
-inline void PakeRegistrationRequestAndUserID::clear_pakeregistrationrequest() {
- pakeregistrationrequest_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::pakeregistrationrequest() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
- return _internal_pakeregistrationrequest();
-}
-inline void PakeRegistrationRequestAndUserID::set_pakeregistrationrequest(const std::string& value) {
- _internal_set_pakeregistrationrequest(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
-}
-inline std::string* PakeRegistrationRequestAndUserID::mutable_pakeregistrationrequest() {
- // @@protoc_insertion_point(field_mutable:identity.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:identity.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:identity.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:identity.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:identity.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:identity.PakeRegistrationRequestAndUserID.pakeRegistrationRequest)
-}
-
-// string username = 4;
-inline void PakeRegistrationRequestAndUserID::clear_username() {
- username_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::username() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.username)
- return _internal_username();
-}
-inline void PakeRegistrationRequestAndUserID::set_username(const std::string& value) {
- _internal_set_username(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.username)
-}
-inline std::string* PakeRegistrationRequestAndUserID::mutable_username() {
- // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.username)
- return _internal_mutable_username();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::_internal_username() const {
- return username_.Get();
-}
-inline void PakeRegistrationRequestAndUserID::_internal_set_username(const std::string& value) {
-
- username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::set_username(std::string&& value) {
-
- username_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.username)
-}
-inline void PakeRegistrationRequestAndUserID::set_username(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationRequestAndUserID.username)
-}
-inline void PakeRegistrationRequestAndUserID::set_username(const char* value,
- size_t size) {
-
- username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationRequestAndUserID.username)
-}
-inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_username() {
-
- return username_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeRegistrationRequestAndUserID::release_username() {
- // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.username)
- return username_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::set_allocated_username(std::string* username) {
- if (username != nullptr) {
-
- } else {
-
- }
- username_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), username,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationRequestAndUserID.username)
-}
-
-// string userPublicKey = 5;
-inline void PakeRegistrationRequestAndUserID::clear_userpublickey() {
- userpublickey_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::userpublickey() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationRequestAndUserID.userPublicKey)
- return _internal_userpublickey();
-}
-inline void PakeRegistrationRequestAndUserID::set_userpublickey(const std::string& value) {
- _internal_set_userpublickey(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationRequestAndUserID.userPublicKey)
-}
-inline std::string* PakeRegistrationRequestAndUserID::mutable_userpublickey() {
- // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationRequestAndUserID.userPublicKey)
- return _internal_mutable_userpublickey();
-}
-inline const std::string& PakeRegistrationRequestAndUserID::_internal_userpublickey() const {
- return userpublickey_.Get();
-}
-inline void PakeRegistrationRequestAndUserID::_internal_set_userpublickey(const std::string& value) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::set_userpublickey(std::string&& value) {
-
- userpublickey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationRequestAndUserID.userPublicKey)
-}
-inline void PakeRegistrationRequestAndUserID::set_userpublickey(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationRequestAndUserID.userPublicKey)
-}
-inline void PakeRegistrationRequestAndUserID::set_userpublickey(const char* value,
- size_t size) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationRequestAndUserID.userPublicKey)
-}
-inline std::string* PakeRegistrationRequestAndUserID::_internal_mutable_userpublickey() {
-
- return userpublickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeRegistrationRequestAndUserID::release_userpublickey() {
- // @@protoc_insertion_point(field_release:identity.PakeRegistrationRequestAndUserID.userPublicKey)
- return userpublickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeRegistrationRequestAndUserID::set_allocated_userpublickey(std::string* userpublickey) {
- if (userpublickey != nullptr) {
-
- } else {
-
- }
- userpublickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userpublickey,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationRequestAndUserID.userPublicKey)
-}
-
-// -------------------------------------------------------------------
-
-// PakeCredentialRequestAndUserID
-
-// string userID = 1;
-inline void PakeCredentialRequestAndUserID::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& PakeCredentialRequestAndUserID::userid() const {
- // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.userID)
- return _internal_userid();
-}
-inline void PakeCredentialRequestAndUserID::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.userID)
-}
-inline std::string* PakeCredentialRequestAndUserID::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.userID)
- return _internal_mutable_userid();
-}
-inline const std::string& PakeCredentialRequestAndUserID::_internal_userid() const {
- return userid_.Get();
-}
-inline void PakeCredentialRequestAndUserID::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.userID)
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
-}
-inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeCredentialRequestAndUserID::release_userid() {
- // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.userID)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.userID)
-}
-
-// string deviceID = 2;
-inline void PakeCredentialRequestAndUserID::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& PakeCredentialRequestAndUserID::deviceid() const {
- // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.deviceID)
- return _internal_deviceid();
-}
-inline void PakeCredentialRequestAndUserID::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.deviceID)
-}
-inline std::string* PakeCredentialRequestAndUserID::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& PakeCredentialRequestAndUserID::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void PakeCredentialRequestAndUserID::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.deviceID)
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
-}
-inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeCredentialRequestAndUserID::release_deviceid() {
- // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeCredentialRequestAndUserID::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:identity.PakeCredentialRequestAndUserID.deviceID)
-}
-
-// bytes pakeCredentialRequest = 3;
-inline void PakeCredentialRequestAndUserID::clear_pakecredentialrequest() {
- pakecredentialrequest_.ClearToEmpty();
-}
-inline const std::string& PakeCredentialRequestAndUserID::pakecredentialrequest() const {
- // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
- return _internal_pakecredentialrequest();
-}
-inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const std::string& value) {
- _internal_set_pakecredentialrequest(value);
- // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
-}
-inline std::string* PakeCredentialRequestAndUserID::mutable_pakecredentialrequest() {
- // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
- return _internal_mutable_pakecredentialrequest();
-}
-inline const std::string& PakeCredentialRequestAndUserID::_internal_pakecredentialrequest() const {
- return pakecredentialrequest_.Get();
-}
-inline void PakeCredentialRequestAndUserID::_internal_set_pakecredentialrequest(const std::string& value) {
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(std::string&& value) {
-
- pakecredentialrequest_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
-}
-inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
-}
-inline void PakeCredentialRequestAndUserID::set_pakecredentialrequest(const void* value,
- size_t size) {
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
-}
-inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_pakecredentialrequest() {
-
- return pakecredentialrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeCredentialRequestAndUserID::release_pakecredentialrequest() {
- // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
- return pakecredentialrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
- if (pakecredentialrequest != nullptr) {
-
- } else {
-
- }
- pakecredentialrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakecredentialrequest,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeCredentialRequestAndUserID.pakeCredentialRequest)
-}
-
-// string userPublicKey = 4;
-inline void PakeCredentialRequestAndUserID::clear_userpublickey() {
- userpublickey_.ClearToEmpty();
-}
-inline const std::string& PakeCredentialRequestAndUserID::userpublickey() const {
- // @@protoc_insertion_point(field_get:identity.PakeCredentialRequestAndUserID.userPublicKey)
- return _internal_userpublickey();
-}
-inline void PakeCredentialRequestAndUserID::set_userpublickey(const std::string& value) {
- _internal_set_userpublickey(value);
- // @@protoc_insertion_point(field_set:identity.PakeCredentialRequestAndUserID.userPublicKey)
-}
-inline std::string* PakeCredentialRequestAndUserID::mutable_userpublickey() {
- // @@protoc_insertion_point(field_mutable:identity.PakeCredentialRequestAndUserID.userPublicKey)
- return _internal_mutable_userpublickey();
-}
-inline const std::string& PakeCredentialRequestAndUserID::_internal_userpublickey() const {
- return userpublickey_.Get();
-}
-inline void PakeCredentialRequestAndUserID::_internal_set_userpublickey(const std::string& value) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_userpublickey(std::string&& value) {
-
- userpublickey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeCredentialRequestAndUserID.userPublicKey)
-}
-inline void PakeCredentialRequestAndUserID::set_userpublickey(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeCredentialRequestAndUserID.userPublicKey)
-}
-inline void PakeCredentialRequestAndUserID::set_userpublickey(const char* value,
- size_t size) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeCredentialRequestAndUserID.userPublicKey)
-}
-inline std::string* PakeCredentialRequestAndUserID::_internal_mutable_userpublickey() {
-
- return userpublickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeCredentialRequestAndUserID::release_userpublickey() {
- // @@protoc_insertion_point(field_release:identity.PakeCredentialRequestAndUserID.userPublicKey)
- return userpublickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeCredentialRequestAndUserID::set_allocated_userpublickey(std::string* userpublickey) {
- if (userpublickey != nullptr) {
-
- } else {
-
- }
- userpublickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userpublickey,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeCredentialRequestAndUserID.userPublicKey)
-}
-
-// -------------------------------------------------------------------
-
-// PakeLoginRequest
-
-// .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
-inline bool PakeLoginRequest::_internal_has_pakecredentialrequestanduserid() const {
- return data_case() == kPakeCredentialRequestAndUserID;
-}
-inline bool PakeLoginRequest::has_pakecredentialrequestanduserid() const {
- return _internal_has_pakecredentialrequestanduserid();
-}
-inline void PakeLoginRequest::set_has_pakecredentialrequestanduserid() {
- _oneof_case_[0] = kPakeCredentialRequestAndUserID;
-}
-inline void PakeLoginRequest::clear_pakecredentialrequestanduserid() {
- if (_internal_has_pakecredentialrequestanduserid()) {
- if (GetArena() == nullptr) {
- delete data_.pakecredentialrequestanduserid_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::release_pakecredentialrequestanduserid() {
- // @@protoc_insertion_point(field_release:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
- if (_internal_has_pakecredentialrequestanduserid()) {
- clear_has_data();
- ::identity::PakeCredentialRequestAndUserID* temp = data_.pakecredentialrequestanduserid_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakecredentialrequestanduserid_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeCredentialRequestAndUserID& PakeLoginRequest::_internal_pakecredentialrequestanduserid() const {
- return _internal_has_pakecredentialrequestanduserid()
- ? *data_.pakecredentialrequestanduserid_
- : reinterpret_cast< ::identity::PakeCredentialRequestAndUserID&>(::identity::_PakeCredentialRequestAndUserID_default_instance_);
-}
-inline const ::identity::PakeCredentialRequestAndUserID& PakeLoginRequest::pakecredentialrequestanduserid() const {
- // @@protoc_insertion_point(field_get:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
- return _internal_pakecredentialrequestanduserid();
-}
-inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::unsafe_arena_release_pakecredentialrequestanduserid() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
- if (_internal_has_pakecredentialrequestanduserid()) {
- clear_has_data();
- ::identity::PakeCredentialRequestAndUserID* temp = data_.pakecredentialrequestanduserid_;
- data_.pakecredentialrequestanduserid_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void PakeLoginRequest::unsafe_arena_set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid) {
- clear_data();
- if (pakecredentialrequestanduserid) {
- set_has_pakecredentialrequestanduserid();
- data_.pakecredentialrequestanduserid_ = pakecredentialrequestanduserid;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
-}
-inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::_internal_mutable_pakecredentialrequestanduserid() {
- if (!_internal_has_pakecredentialrequestanduserid()) {
- clear_data();
- set_has_pakecredentialrequestanduserid();
- data_.pakecredentialrequestanduserid_ = CreateMaybeMessage< ::identity::PakeCredentialRequestAndUserID >(GetArena());
- }
- return data_.pakecredentialrequestanduserid_;
-}
-inline ::identity::PakeCredentialRequestAndUserID* PakeLoginRequest::mutable_pakecredentialrequestanduserid() {
- // @@protoc_insertion_point(field_mutable:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
- return _internal_mutable_pakecredentialrequestanduserid();
-}
-
-// bytes pakeCredentialFinalization = 2;
-inline bool PakeLoginRequest::_internal_has_pakecredentialfinalization() const {
- return data_case() == kPakeCredentialFinalization;
-}
-inline bool PakeLoginRequest::has_pakecredentialfinalization() const {
- return _internal_has_pakecredentialfinalization();
-}
-inline void PakeLoginRequest::set_has_pakecredentialfinalization() {
- _oneof_case_[0] = kPakeCredentialFinalization;
-}
-inline void PakeLoginRequest::clear_pakecredentialfinalization() {
- if (_internal_has_pakecredentialfinalization()) {
- data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- clear_has_data();
- }
-}
-inline const std::string& PakeLoginRequest::pakecredentialfinalization() const {
- // @@protoc_insertion_point(field_get:identity.PakeLoginRequest.pakeCredentialFinalization)
- return _internal_pakecredentialfinalization();
-}
-inline void PakeLoginRequest::set_pakecredentialfinalization(const std::string& value) {
- _internal_set_pakecredentialfinalization(value);
- // @@protoc_insertion_point(field_set:identity.PakeLoginRequest.pakeCredentialFinalization)
-}
-inline std::string* PakeLoginRequest::mutable_pakecredentialfinalization() {
- // @@protoc_insertion_point(field_mutable:identity.PakeLoginRequest.pakeCredentialFinalization)
- return _internal_mutable_pakecredentialfinalization();
-}
-inline const std::string& PakeLoginRequest::_internal_pakecredentialfinalization() const {
- if (_internal_has_pakecredentialfinalization()) {
- return data_.pakecredentialfinalization_.Get();
- }
- return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void PakeLoginRequest::_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 PakeLoginRequest::set_pakecredentialfinalization(std::string&& value) {
- // @@protoc_insertion_point(field_set:identity.PakeLoginRequest.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:identity.PakeLoginRequest.pakeCredentialFinalization)
-}
-inline void PakeLoginRequest::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:identity.PakeLoginRequest.pakeCredentialFinalization)
-}
-inline void PakeLoginRequest::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:identity.PakeLoginRequest.pakeCredentialFinalization)
-}
-inline std::string* PakeLoginRequest::_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* PakeLoginRequest::release_pakecredentialfinalization() {
- // @@protoc_insertion_point(field_release:identity.PakeLoginRequest.pakeCredentialFinalization)
- if (_internal_has_pakecredentialfinalization()) {
- clear_has_data();
- return data_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- } else {
- return nullptr;
- }
-}
-inline void PakeLoginRequest::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:identity.PakeLoginRequest.pakeCredentialFinalization)
-}
-
-inline bool PakeLoginRequest::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void PakeLoginRequest::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline PakeLoginRequest::DataCase PakeLoginRequest::data_case() const {
- return PakeLoginRequest::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// PakeLoginResponse
-
-// bytes pakeCredentialResponse = 1;
-inline bool PakeLoginResponse::_internal_has_pakecredentialresponse() const {
- return data_case() == kPakeCredentialResponse;
-}
-inline bool PakeLoginResponse::has_pakecredentialresponse() const {
- return _internal_has_pakecredentialresponse();
-}
-inline void PakeLoginResponse::set_has_pakecredentialresponse() {
- _oneof_case_[0] = kPakeCredentialResponse;
-}
-inline void PakeLoginResponse::clear_pakecredentialresponse() {
- if (_internal_has_pakecredentialresponse()) {
- data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- clear_has_data();
- }
-}
-inline const std::string& PakeLoginResponse::pakecredentialresponse() const {
- // @@protoc_insertion_point(field_get:identity.PakeLoginResponse.pakeCredentialResponse)
- return _internal_pakecredentialresponse();
-}
-inline void PakeLoginResponse::set_pakecredentialresponse(const std::string& value) {
- _internal_set_pakecredentialresponse(value);
- // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.pakeCredentialResponse)
-}
-inline std::string* PakeLoginResponse::mutable_pakecredentialresponse() {
- // @@protoc_insertion_point(field_mutable:identity.PakeLoginResponse.pakeCredentialResponse)
- return _internal_mutable_pakecredentialresponse();
-}
-inline const std::string& PakeLoginResponse::_internal_pakecredentialresponse() const {
- if (_internal_has_pakecredentialresponse()) {
- return data_.pakecredentialresponse_.Get();
- }
- return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void PakeLoginResponse::_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 PakeLoginResponse::set_pakecredentialresponse(std::string&& value) {
- // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.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:identity.PakeLoginResponse.pakeCredentialResponse)
-}
-inline void PakeLoginResponse::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:identity.PakeLoginResponse.pakeCredentialResponse)
-}
-inline void PakeLoginResponse::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:identity.PakeLoginResponse.pakeCredentialResponse)
-}
-inline std::string* PakeLoginResponse::_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* PakeLoginResponse::release_pakecredentialresponse() {
- // @@protoc_insertion_point(field_release:identity.PakeLoginResponse.pakeCredentialResponse)
- if (_internal_has_pakecredentialresponse()) {
- clear_has_data();
- return data_.pakecredentialresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- } else {
- return nullptr;
- }
-}
-inline void PakeLoginResponse::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:identity.PakeLoginResponse.pakeCredentialResponse)
-}
-
-// string accessToken = 2;
-inline bool PakeLoginResponse::_internal_has_accesstoken() const {
- return data_case() == kAccessToken;
-}
-inline bool PakeLoginResponse::has_accesstoken() const {
- return _internal_has_accesstoken();
-}
-inline void PakeLoginResponse::set_has_accesstoken() {
- _oneof_case_[0] = kAccessToken;
-}
-inline void PakeLoginResponse::clear_accesstoken() {
- if (_internal_has_accesstoken()) {
- data_.accesstoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- clear_has_data();
- }
-}
-inline const std::string& PakeLoginResponse::accesstoken() const {
- // @@protoc_insertion_point(field_get:identity.PakeLoginResponse.accessToken)
- return _internal_accesstoken();
-}
-inline void PakeLoginResponse::set_accesstoken(const std::string& value) {
- _internal_set_accesstoken(value);
- // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.accessToken)
-}
-inline std::string* PakeLoginResponse::mutable_accesstoken() {
- // @@protoc_insertion_point(field_mutable:identity.PakeLoginResponse.accessToken)
- return _internal_mutable_accesstoken();
-}
-inline const std::string& PakeLoginResponse::_internal_accesstoken() const {
- if (_internal_has_accesstoken()) {
- return data_.accesstoken_.Get();
- }
- return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void PakeLoginResponse::_internal_set_accesstoken(const std::string& value) {
- if (!_internal_has_accesstoken()) {
- clear_data();
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- }
- data_.accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeLoginResponse::set_accesstoken(std::string&& value) {
- // @@protoc_insertion_point(field_set:identity.PakeLoginResponse.accessToken)
- if (!_internal_has_accesstoken()) {
- clear_data();
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- }
- data_.accesstoken_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeLoginResponse.accessToken)
-}
-inline void PakeLoginResponse::set_accesstoken(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
- if (!_internal_has_accesstoken()) {
- clear_data();
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- }
- data_.accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{},
- ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeLoginResponse.accessToken)
-}
-inline void PakeLoginResponse::set_accesstoken(const char* value,
- size_t size) {
- if (!_internal_has_accesstoken()) {
- clear_data();
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- }
- data_.accesstoken_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size),
- GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeLoginResponse.accessToken)
-}
-inline std::string* PakeLoginResponse::_internal_mutable_accesstoken() {
- if (!_internal_has_accesstoken()) {
- clear_data();
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- }
- return data_.accesstoken_.Mutable(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeLoginResponse::release_accesstoken() {
- // @@protoc_insertion_point(field_release:identity.PakeLoginResponse.accessToken)
- if (_internal_has_accesstoken()) {
- clear_has_data();
- return data_.accesstoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- } else {
- return nullptr;
- }
-}
-inline void PakeLoginResponse::set_allocated_accesstoken(std::string* accesstoken) {
- if (has_data()) {
- clear_data();
- }
- if (accesstoken != nullptr) {
- set_has_accesstoken();
- data_.accesstoken_.UnsafeSetDefault(accesstoken);
- ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena();
- if (arena != nullptr) {
- arena->Own(accesstoken);
- }
- }
- // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginResponse.accessToken)
-}
-
-inline bool PakeLoginResponse::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void PakeLoginResponse::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline PakeLoginResponse::DataCase PakeLoginResponse::data_case() const {
- return PakeLoginResponse::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// PakeRegistrationUploadAndCredentialRequest
-
-// bytes pakeRegistrationUpload = 1;
-inline void PakeRegistrationUploadAndCredentialRequest::clear_pakeregistrationupload() {
- pakeregistrationupload_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationUploadAndCredentialRequest::pakeregistrationupload() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
- return _internal_pakeregistrationupload();
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const std::string& value) {
- _internal_set_pakeregistrationupload(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::mutable_pakeregistrationupload() {
- // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
- return _internal_mutable_pakeregistrationupload();
-}
-inline const std::string& PakeRegistrationUploadAndCredentialRequest::_internal_pakeregistrationupload() const {
- return pakeregistrationupload_.Get();
-}
-inline void PakeRegistrationUploadAndCredentialRequest::_internal_set_pakeregistrationupload(const std::string& value) {
-
- pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(std::string&& value) {
-
- pakeregistrationupload_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakeregistrationupload(const void* value,
- size_t size) {
-
- pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::_internal_mutable_pakeregistrationupload() {
-
- return pakeregistrationupload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::release_pakeregistrationupload() {
- // @@protoc_insertion_point(field_release:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
- return pakeregistrationupload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_allocated_pakeregistrationupload(std::string* pakeregistrationupload) {
- if (pakeregistrationupload != nullptr) {
-
- } else {
-
- }
- pakeregistrationupload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakeregistrationupload,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationUploadAndCredentialRequest.pakeRegistrationUpload)
-}
-
-// bytes pakeCredentialRequest = 2;
-inline void PakeRegistrationUploadAndCredentialRequest::clear_pakecredentialrequest() {
- pakecredentialrequest_.ClearToEmpty();
-}
-inline const std::string& PakeRegistrationUploadAndCredentialRequest::pakecredentialrequest() const {
- // @@protoc_insertion_point(field_get:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
- return _internal_pakecredentialrequest();
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const std::string& value) {
- _internal_set_pakecredentialrequest(value);
- // @@protoc_insertion_point(field_set:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::mutable_pakecredentialrequest() {
- // @@protoc_insertion_point(field_mutable:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
- return _internal_mutable_pakecredentialrequest();
-}
-inline const std::string& PakeRegistrationUploadAndCredentialRequest::_internal_pakecredentialrequest() const {
- return pakecredentialrequest_.Get();
-}
-inline void PakeRegistrationUploadAndCredentialRequest::_internal_set_pakecredentialrequest(const std::string& value) {
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(std::string&& value) {
-
- pakecredentialrequest_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_pakecredentialrequest(const void* value,
- size_t size) {
-
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::_internal_mutable_pakecredentialrequest() {
-
- return pakecredentialrequest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* PakeRegistrationUploadAndCredentialRequest::release_pakecredentialrequest() {
- // @@protoc_insertion_point(field_release:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
- return pakecredentialrequest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void PakeRegistrationUploadAndCredentialRequest::set_allocated_pakecredentialrequest(std::string* pakecredentialrequest) {
- if (pakecredentialrequest != nullptr) {
-
- } else {
-
- }
- pakecredentialrequest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pakecredentialrequest,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.PakeRegistrationUploadAndCredentialRequest.pakeCredentialRequest)
-}
-
-// -------------------------------------------------------------------
-
-// WalletLoginRequest
-
-// string userID = 1;
-inline void WalletLoginRequest::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& WalletLoginRequest::userid() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.userID)
- return _internal_userid();
-}
-inline void WalletLoginRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.userID)
-}
-inline std::string* WalletLoginRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.userID)
- return _internal_mutable_userid();
-}
-inline const std::string& WalletLoginRequest::_internal_userid() const {
- return userid_.Get();
-}
-inline void WalletLoginRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.userID)
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
-}
-inline std::string* WalletLoginRequest::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginRequest::release_userid() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.userID)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.userID)
-}
-
-// string deviceID = 2;
-inline void WalletLoginRequest::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& WalletLoginRequest::deviceid() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.deviceID)
- return _internal_deviceid();
-}
-inline void WalletLoginRequest::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.deviceID)
-}
-inline std::string* WalletLoginRequest::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& WalletLoginRequest::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void WalletLoginRequest::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginRequest::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.deviceID)
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
-}
-inline std::string* WalletLoginRequest::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginRequest::release_deviceid() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginRequest::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:identity.WalletLoginRequest.deviceID)
-}
-
-// string siweMessage = 3;
-inline void WalletLoginRequest::clear_siwemessage() {
- siwemessage_.ClearToEmpty();
-}
-inline const std::string& WalletLoginRequest::siwemessage() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.siweMessage)
- return _internal_siwemessage();
-}
-inline void WalletLoginRequest::set_siwemessage(const std::string& value) {
- _internal_set_siwemessage(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.siweMessage)
-}
-inline std::string* WalletLoginRequest::mutable_siwemessage() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.siweMessage)
- return _internal_mutable_siwemessage();
-}
-inline const std::string& WalletLoginRequest::_internal_siwemessage() const {
- return siwemessage_.Get();
-}
-inline void WalletLoginRequest::_internal_set_siwemessage(const std::string& value) {
-
- siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginRequest::set_siwemessage(std::string&& value) {
-
- siwemessage_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.siweMessage)
-}
-inline void WalletLoginRequest::set_siwemessage(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.WalletLoginRequest.siweMessage)
-}
-inline void WalletLoginRequest::set_siwemessage(const char* value,
- size_t size) {
-
- siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginRequest.siweMessage)
-}
-inline std::string* WalletLoginRequest::_internal_mutable_siwemessage() {
-
- return siwemessage_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginRequest::release_siwemessage() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.siweMessage)
- return siwemessage_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginRequest::set_allocated_siwemessage(std::string* siwemessage) {
- if (siwemessage != nullptr) {
-
- } else {
-
- }
- siwemessage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), siwemessage,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginRequest.siweMessage)
-}
-
-// bytes siweSignature = 4;
-inline void WalletLoginRequest::clear_siwesignature() {
- siwesignature_.ClearToEmpty();
-}
-inline const std::string& WalletLoginRequest::siwesignature() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.siweSignature)
- return _internal_siwesignature();
-}
-inline void WalletLoginRequest::set_siwesignature(const std::string& value) {
- _internal_set_siwesignature(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.siweSignature)
-}
-inline std::string* WalletLoginRequest::mutable_siwesignature() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.siweSignature)
- return _internal_mutable_siwesignature();
-}
-inline const std::string& WalletLoginRequest::_internal_siwesignature() const {
- return siwesignature_.Get();
-}
-inline void WalletLoginRequest::_internal_set_siwesignature(const std::string& value) {
-
- siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginRequest::set_siwesignature(std::string&& value) {
-
- siwesignature_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.siweSignature)
-}
-inline void WalletLoginRequest::set_siwesignature(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.WalletLoginRequest.siweSignature)
-}
-inline void WalletLoginRequest::set_siwesignature(const void* value,
- size_t size) {
-
- siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginRequest.siweSignature)
-}
-inline std::string* WalletLoginRequest::_internal_mutable_siwesignature() {
-
- return siwesignature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginRequest::release_siwesignature() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.siweSignature)
- return siwesignature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginRequest::set_allocated_siwesignature(std::string* siwesignature) {
- if (siwesignature != nullptr) {
-
- } else {
-
- }
- siwesignature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), siwesignature,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginRequest.siweSignature)
-}
-
-// string userPublicKey = 5;
-inline void WalletLoginRequest::clear_userpublickey() {
- userpublickey_.ClearToEmpty();
-}
-inline const std::string& WalletLoginRequest::userpublickey() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginRequest.userPublicKey)
- return _internal_userpublickey();
-}
-inline void WalletLoginRequest::set_userpublickey(const std::string& value) {
- _internal_set_userpublickey(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginRequest.userPublicKey)
-}
-inline std::string* WalletLoginRequest::mutable_userpublickey() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginRequest.userPublicKey)
- return _internal_mutable_userpublickey();
-}
-inline const std::string& WalletLoginRequest::_internal_userpublickey() const {
- return userpublickey_.Get();
-}
-inline void WalletLoginRequest::_internal_set_userpublickey(const std::string& value) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginRequest::set_userpublickey(std::string&& value) {
-
- userpublickey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginRequest.userPublicKey)
-}
-inline void WalletLoginRequest::set_userpublickey(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.WalletLoginRequest.userPublicKey)
-}
-inline void WalletLoginRequest::set_userpublickey(const char* value,
- size_t size) {
-
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginRequest.userPublicKey)
-}
-inline std::string* WalletLoginRequest::_internal_mutable_userpublickey() {
-
- return userpublickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginRequest::release_userpublickey() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginRequest.userPublicKey)
- return userpublickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginRequest::set_allocated_userpublickey(std::string* userpublickey) {
- if (userpublickey != nullptr) {
-
- } else {
-
- }
- userpublickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userpublickey,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginRequest.userPublicKey)
-}
-
-// -------------------------------------------------------------------
-
-// WalletLoginResponse
-
-// string accessToken = 1;
-inline void WalletLoginResponse::clear_accesstoken() {
- accesstoken_.ClearToEmpty();
-}
-inline const std::string& WalletLoginResponse::accesstoken() const {
- // @@protoc_insertion_point(field_get:identity.WalletLoginResponse.accessToken)
- return _internal_accesstoken();
-}
-inline void WalletLoginResponse::set_accesstoken(const std::string& value) {
- _internal_set_accesstoken(value);
- // @@protoc_insertion_point(field_set:identity.WalletLoginResponse.accessToken)
-}
-inline std::string* WalletLoginResponse::mutable_accesstoken() {
- // @@protoc_insertion_point(field_mutable:identity.WalletLoginResponse.accessToken)
- return _internal_mutable_accesstoken();
-}
-inline const std::string& WalletLoginResponse::_internal_accesstoken() const {
- return accesstoken_.Get();
-}
-inline void WalletLoginResponse::_internal_set_accesstoken(const std::string& value) {
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void WalletLoginResponse::set_accesstoken(std::string&& value) {
-
- accesstoken_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.WalletLoginResponse.accessToken)
-}
-inline void WalletLoginResponse::set_accesstoken(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.WalletLoginResponse.accessToken)
-}
-inline void WalletLoginResponse::set_accesstoken(const char* value,
- size_t size) {
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.WalletLoginResponse.accessToken)
-}
-inline std::string* WalletLoginResponse::_internal_mutable_accesstoken() {
-
- return accesstoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* WalletLoginResponse::release_accesstoken() {
- // @@protoc_insertion_point(field_release:identity.WalletLoginResponse.accessToken)
- return accesstoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void WalletLoginResponse::set_allocated_accesstoken(std::string* accesstoken) {
- if (accesstoken != nullptr) {
-
- } else {
-
- }
- accesstoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), accesstoken,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.WalletLoginResponse.accessToken)
-}
-
-// -------------------------------------------------------------------
-
-// RegistrationRequest
-
-// .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
-inline bool RegistrationRequest::_internal_has_pakeregistrationrequestanduserid() const {
- return data_case() == kPakeRegistrationRequestAndUserID;
-}
-inline bool RegistrationRequest::has_pakeregistrationrequestanduserid() const {
- return _internal_has_pakeregistrationrequestanduserid();
-}
-inline void RegistrationRequest::set_has_pakeregistrationrequestanduserid() {
- _oneof_case_[0] = kPakeRegistrationRequestAndUserID;
-}
-inline void RegistrationRequest::clear_pakeregistrationrequestanduserid() {
- if (_internal_has_pakeregistrationrequestanduserid()) {
- if (GetArena() == nullptr) {
- delete data_.pakeregistrationrequestanduserid_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::release_pakeregistrationrequestanduserid() {
- // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
- if (_internal_has_pakeregistrationrequestanduserid()) {
- clear_has_data();
- ::identity::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakeregistrationrequestanduserid_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeRegistrationRequestAndUserID& RegistrationRequest::_internal_pakeregistrationrequestanduserid() const {
- return _internal_has_pakeregistrationrequestanduserid()
- ? *data_.pakeregistrationrequestanduserid_
- : reinterpret_cast< ::identity::PakeRegistrationRequestAndUserID&>(::identity::_PakeRegistrationRequestAndUserID_default_instance_);
-}
-inline const ::identity::PakeRegistrationRequestAndUserID& RegistrationRequest::pakeregistrationrequestanduserid() const {
- // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
- return _internal_pakeregistrationrequestanduserid();
-}
-inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::unsafe_arena_release_pakeregistrationrequestanduserid() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
- if (_internal_has_pakeregistrationrequestanduserid()) {
- clear_has_data();
- ::identity::PakeRegistrationRequestAndUserID* temp = data_.pakeregistrationrequestanduserid_;
- data_.pakeregistrationrequestanduserid_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void RegistrationRequest::unsafe_arena_set_allocated_pakeregistrationrequestanduserid(::identity::PakeRegistrationRequestAndUserID* pakeregistrationrequestanduserid) {
- clear_data();
- if (pakeregistrationrequestanduserid) {
- set_has_pakeregistrationrequestanduserid();
- data_.pakeregistrationrequestanduserid_ = pakeregistrationrequestanduserid;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
-}
-inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::_internal_mutable_pakeregistrationrequestanduserid() {
- if (!_internal_has_pakeregistrationrequestanduserid()) {
- clear_data();
- set_has_pakeregistrationrequestanduserid();
- data_.pakeregistrationrequestanduserid_ = CreateMaybeMessage< ::identity::PakeRegistrationRequestAndUserID >(GetArena());
- }
- return data_.pakeregistrationrequestanduserid_;
-}
-inline ::identity::PakeRegistrationRequestAndUserID* RegistrationRequest::mutable_pakeregistrationrequestanduserid() {
- // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
- return _internal_mutable_pakeregistrationrequestanduserid();
-}
-
-// .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
-inline bool RegistrationRequest::_internal_has_pakeregistrationuploadandcredentialrequest() const {
- return data_case() == kPakeRegistrationUploadAndCredentialRequest;
-}
-inline bool RegistrationRequest::has_pakeregistrationuploadandcredentialrequest() const {
- return _internal_has_pakeregistrationuploadandcredentialrequest();
-}
-inline void RegistrationRequest::set_has_pakeregistrationuploadandcredentialrequest() {
- _oneof_case_[0] = kPakeRegistrationUploadAndCredentialRequest;
-}
-inline void RegistrationRequest::clear_pakeregistrationuploadandcredentialrequest() {
- if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
- if (GetArena() == nullptr) {
- delete data_.pakeregistrationuploadandcredentialrequest_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::release_pakeregistrationuploadandcredentialrequest() {
- // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
- if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
- clear_has_data();
- ::identity::PakeRegistrationUploadAndCredentialRequest* temp = data_.pakeregistrationuploadandcredentialrequest_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakeregistrationuploadandcredentialrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeRegistrationUploadAndCredentialRequest& RegistrationRequest::_internal_pakeregistrationuploadandcredentialrequest() const {
- return _internal_has_pakeregistrationuploadandcredentialrequest()
- ? *data_.pakeregistrationuploadandcredentialrequest_
- : reinterpret_cast< ::identity::PakeRegistrationUploadAndCredentialRequest&>(::identity::_PakeRegistrationUploadAndCredentialRequest_default_instance_);
-}
-inline const ::identity::PakeRegistrationUploadAndCredentialRequest& RegistrationRequest::pakeregistrationuploadandcredentialrequest() const {
- // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
- return _internal_pakeregistrationuploadandcredentialrequest();
-}
-inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::unsafe_arena_release_pakeregistrationuploadandcredentialrequest() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
- if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
- clear_has_data();
- ::identity::PakeRegistrationUploadAndCredentialRequest* temp = data_.pakeregistrationuploadandcredentialrequest_;
- data_.pakeregistrationuploadandcredentialrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void RegistrationRequest::unsafe_arena_set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest) {
- clear_data();
- if (pakeregistrationuploadandcredentialrequest) {
- set_has_pakeregistrationuploadandcredentialrequest();
- data_.pakeregistrationuploadandcredentialrequest_ = pakeregistrationuploadandcredentialrequest;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
-}
-inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::_internal_mutable_pakeregistrationuploadandcredentialrequest() {
- if (!_internal_has_pakeregistrationuploadandcredentialrequest()) {
- clear_data();
- set_has_pakeregistrationuploadandcredentialrequest();
- data_.pakeregistrationuploadandcredentialrequest_ = CreateMaybeMessage< ::identity::PakeRegistrationUploadAndCredentialRequest >(GetArena());
- }
- return data_.pakeregistrationuploadandcredentialrequest_;
-}
-inline ::identity::PakeRegistrationUploadAndCredentialRequest* RegistrationRequest::mutable_pakeregistrationuploadandcredentialrequest() {
- // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
- return _internal_mutable_pakeregistrationuploadandcredentialrequest();
-}
-
-// bytes pakeCredentialFinalization = 3;
-inline bool RegistrationRequest::_internal_has_pakecredentialfinalization() const {
- return data_case() == kPakeCredentialFinalization;
-}
-inline bool RegistrationRequest::has_pakecredentialfinalization() const {
- return _internal_has_pakecredentialfinalization();
-}
-inline void RegistrationRequest::set_has_pakecredentialfinalization() {
- _oneof_case_[0] = kPakeCredentialFinalization;
-}
-inline void RegistrationRequest::clear_pakecredentialfinalization() {
- if (_internal_has_pakecredentialfinalization()) {
- data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- clear_has_data();
- }
-}
-inline const std::string& RegistrationRequest::pakecredentialfinalization() const {
- // @@protoc_insertion_point(field_get:identity.RegistrationRequest.pakeCredentialFinalization)
- return _internal_pakecredentialfinalization();
-}
-inline void RegistrationRequest::set_pakecredentialfinalization(const std::string& value) {
- _internal_set_pakecredentialfinalization(value);
- // @@protoc_insertion_point(field_set:identity.RegistrationRequest.pakeCredentialFinalization)
-}
-inline std::string* RegistrationRequest::mutable_pakecredentialfinalization() {
- // @@protoc_insertion_point(field_mutable:identity.RegistrationRequest.pakeCredentialFinalization)
- return _internal_mutable_pakecredentialfinalization();
-}
-inline const std::string& RegistrationRequest::_internal_pakecredentialfinalization() const {
- if (_internal_has_pakecredentialfinalization()) {
- return data_.pakecredentialfinalization_.Get();
- }
- return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void RegistrationRequest::_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 RegistrationRequest::set_pakecredentialfinalization(std::string&& value) {
- // @@protoc_insertion_point(field_set:identity.RegistrationRequest.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:identity.RegistrationRequest.pakeCredentialFinalization)
-}
-inline void RegistrationRequest::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:identity.RegistrationRequest.pakeCredentialFinalization)
-}
-inline void RegistrationRequest::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:identity.RegistrationRequest.pakeCredentialFinalization)
-}
-inline std::string* RegistrationRequest::_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* RegistrationRequest::release_pakecredentialfinalization() {
- // @@protoc_insertion_point(field_release:identity.RegistrationRequest.pakeCredentialFinalization)
- if (_internal_has_pakecredentialfinalization()) {
- clear_has_data();
- return data_.pakecredentialfinalization_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- } else {
- return nullptr;
- }
-}
-inline void RegistrationRequest::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:identity.RegistrationRequest.pakeCredentialFinalization)
-}
-
-inline bool RegistrationRequest::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void RegistrationRequest::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline RegistrationRequest::DataCase RegistrationRequest::data_case() const {
- return RegistrationRequest::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// RegistrationResponse
-
-// bytes pakeRegistrationResponse = 1;
-inline bool RegistrationResponse::_internal_has_pakeregistrationresponse() const {
- return data_case() == kPakeRegistrationResponse;
-}
-inline bool RegistrationResponse::has_pakeregistrationresponse() const {
- return _internal_has_pakeregistrationresponse();
-}
-inline void RegistrationResponse::set_has_pakeregistrationresponse() {
- _oneof_case_[0] = kPakeRegistrationResponse;
-}
-inline void RegistrationResponse::clear_pakeregistrationresponse() {
- if (_internal_has_pakeregistrationresponse()) {
- data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- clear_has_data();
- }
-}
-inline const std::string& RegistrationResponse::pakeregistrationresponse() const {
- // @@protoc_insertion_point(field_get:identity.RegistrationResponse.pakeRegistrationResponse)
- return _internal_pakeregistrationresponse();
-}
-inline void RegistrationResponse::set_pakeregistrationresponse(const std::string& value) {
- _internal_set_pakeregistrationresponse(value);
- // @@protoc_insertion_point(field_set:identity.RegistrationResponse.pakeRegistrationResponse)
-}
-inline std::string* RegistrationResponse::mutable_pakeregistrationresponse() {
- // @@protoc_insertion_point(field_mutable:identity.RegistrationResponse.pakeRegistrationResponse)
- return _internal_mutable_pakeregistrationresponse();
-}
-inline const std::string& RegistrationResponse::_internal_pakeregistrationresponse() const {
- if (_internal_has_pakeregistrationresponse()) {
- return data_.pakeregistrationresponse_.Get();
- }
- return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
-}
-inline void RegistrationResponse::_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 RegistrationResponse::set_pakeregistrationresponse(std::string&& value) {
- // @@protoc_insertion_point(field_set:identity.RegistrationResponse.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:identity.RegistrationResponse.pakeRegistrationResponse)
-}
-inline void RegistrationResponse::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:identity.RegistrationResponse.pakeRegistrationResponse)
-}
-inline void RegistrationResponse::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:identity.RegistrationResponse.pakeRegistrationResponse)
-}
-inline std::string* RegistrationResponse::_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* RegistrationResponse::release_pakeregistrationresponse() {
- // @@protoc_insertion_point(field_release:identity.RegistrationResponse.pakeRegistrationResponse)
- if (_internal_has_pakeregistrationresponse()) {
- clear_has_data();
- return data_.pakeregistrationresponse_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- } else {
- return nullptr;
- }
-}
-inline void RegistrationResponse::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:identity.RegistrationResponse.pakeRegistrationResponse)
-}
-
-// .identity.PakeLoginResponse pakeLoginResponse = 2;
-inline bool RegistrationResponse::_internal_has_pakeloginresponse() const {
- return data_case() == kPakeLoginResponse;
-}
-inline bool RegistrationResponse::has_pakeloginresponse() const {
- return _internal_has_pakeloginresponse();
-}
-inline void RegistrationResponse::set_has_pakeloginresponse() {
- _oneof_case_[0] = kPakeLoginResponse;
-}
-inline void RegistrationResponse::clear_pakeloginresponse() {
- if (_internal_has_pakeloginresponse()) {
- if (GetArena() == nullptr) {
- delete data_.pakeloginresponse_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeLoginResponse* RegistrationResponse::release_pakeloginresponse() {
- // @@protoc_insertion_point(field_release:identity.RegistrationResponse.pakeLoginResponse)
- if (_internal_has_pakeloginresponse()) {
- clear_has_data();
- ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakeloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeLoginResponse& RegistrationResponse::_internal_pakeloginresponse() const {
- return _internal_has_pakeloginresponse()
- ? *data_.pakeloginresponse_
- : reinterpret_cast< ::identity::PakeLoginResponse&>(::identity::_PakeLoginResponse_default_instance_);
-}
-inline const ::identity::PakeLoginResponse& RegistrationResponse::pakeloginresponse() const {
- // @@protoc_insertion_point(field_get:identity.RegistrationResponse.pakeLoginResponse)
- return _internal_pakeloginresponse();
-}
-inline ::identity::PakeLoginResponse* RegistrationResponse::unsafe_arena_release_pakeloginresponse() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.RegistrationResponse.pakeLoginResponse)
- if (_internal_has_pakeloginresponse()) {
- clear_has_data();
- ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
- data_.pakeloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void RegistrationResponse::unsafe_arena_set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
- clear_data();
- if (pakeloginresponse) {
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = pakeloginresponse;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.RegistrationResponse.pakeLoginResponse)
-}
-inline ::identity::PakeLoginResponse* RegistrationResponse::_internal_mutable_pakeloginresponse() {
- if (!_internal_has_pakeloginresponse()) {
- clear_data();
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = CreateMaybeMessage< ::identity::PakeLoginResponse >(GetArena());
- }
- return data_.pakeloginresponse_;
-}
-inline ::identity::PakeLoginResponse* RegistrationResponse::mutable_pakeloginresponse() {
- // @@protoc_insertion_point(field_mutable:identity.RegistrationResponse.pakeLoginResponse)
- return _internal_mutable_pakeloginresponse();
-}
-
-inline bool RegistrationResponse::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void RegistrationResponse::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline RegistrationResponse::DataCase RegistrationResponse::data_case() const {
- return RegistrationResponse::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// LoginRequest
-
-// .identity.PakeLoginRequest pakeLoginRequest = 1;
-inline bool LoginRequest::_internal_has_pakeloginrequest() const {
- return data_case() == kPakeLoginRequest;
-}
-inline bool LoginRequest::has_pakeloginrequest() const {
- return _internal_has_pakeloginrequest();
-}
-inline void LoginRequest::set_has_pakeloginrequest() {
- _oneof_case_[0] = kPakeLoginRequest;
-}
-inline void LoginRequest::clear_pakeloginrequest() {
- if (_internal_has_pakeloginrequest()) {
- if (GetArena() == nullptr) {
- delete data_.pakeloginrequest_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeLoginRequest* LoginRequest::release_pakeloginrequest() {
- // @@protoc_insertion_point(field_release:identity.LoginRequest.pakeLoginRequest)
- if (_internal_has_pakeloginrequest()) {
- clear_has_data();
- ::identity::PakeLoginRequest* temp = data_.pakeloginrequest_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakeloginrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeLoginRequest& LoginRequest::_internal_pakeloginrequest() const {
- return _internal_has_pakeloginrequest()
- ? *data_.pakeloginrequest_
- : reinterpret_cast< ::identity::PakeLoginRequest&>(::identity::_PakeLoginRequest_default_instance_);
-}
-inline const ::identity::PakeLoginRequest& LoginRequest::pakeloginrequest() const {
- // @@protoc_insertion_point(field_get:identity.LoginRequest.pakeLoginRequest)
- return _internal_pakeloginrequest();
-}
-inline ::identity::PakeLoginRequest* LoginRequest::unsafe_arena_release_pakeloginrequest() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginRequest.pakeLoginRequest)
- if (_internal_has_pakeloginrequest()) {
- clear_has_data();
- ::identity::PakeLoginRequest* temp = data_.pakeloginrequest_;
- data_.pakeloginrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void LoginRequest::unsafe_arena_set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest) {
- clear_data();
- if (pakeloginrequest) {
- set_has_pakeloginrequest();
- data_.pakeloginrequest_ = pakeloginrequest;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginRequest.pakeLoginRequest)
-}
-inline ::identity::PakeLoginRequest* LoginRequest::_internal_mutable_pakeloginrequest() {
- if (!_internal_has_pakeloginrequest()) {
- clear_data();
- set_has_pakeloginrequest();
- data_.pakeloginrequest_ = CreateMaybeMessage< ::identity::PakeLoginRequest >(GetArena());
- }
- return data_.pakeloginrequest_;
-}
-inline ::identity::PakeLoginRequest* LoginRequest::mutable_pakeloginrequest() {
- // @@protoc_insertion_point(field_mutable:identity.LoginRequest.pakeLoginRequest)
- return _internal_mutable_pakeloginrequest();
-}
-
-// .identity.WalletLoginRequest walletLoginRequest = 2;
-inline bool LoginRequest::_internal_has_walletloginrequest() const {
- return data_case() == kWalletLoginRequest;
-}
-inline bool LoginRequest::has_walletloginrequest() const {
- return _internal_has_walletloginrequest();
-}
-inline void LoginRequest::set_has_walletloginrequest() {
- _oneof_case_[0] = kWalletLoginRequest;
-}
-inline void LoginRequest::clear_walletloginrequest() {
- if (_internal_has_walletloginrequest()) {
- if (GetArena() == nullptr) {
- delete data_.walletloginrequest_;
- }
- clear_has_data();
- }
-}
-inline ::identity::WalletLoginRequest* LoginRequest::release_walletloginrequest() {
- // @@protoc_insertion_point(field_release:identity.LoginRequest.walletLoginRequest)
- if (_internal_has_walletloginrequest()) {
- clear_has_data();
- ::identity::WalletLoginRequest* temp = data_.walletloginrequest_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.walletloginrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::WalletLoginRequest& LoginRequest::_internal_walletloginrequest() const {
- return _internal_has_walletloginrequest()
- ? *data_.walletloginrequest_
- : reinterpret_cast< ::identity::WalletLoginRequest&>(::identity::_WalletLoginRequest_default_instance_);
-}
-inline const ::identity::WalletLoginRequest& LoginRequest::walletloginrequest() const {
- // @@protoc_insertion_point(field_get:identity.LoginRequest.walletLoginRequest)
- return _internal_walletloginrequest();
-}
-inline ::identity::WalletLoginRequest* LoginRequest::unsafe_arena_release_walletloginrequest() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginRequest.walletLoginRequest)
- if (_internal_has_walletloginrequest()) {
- clear_has_data();
- ::identity::WalletLoginRequest* temp = data_.walletloginrequest_;
- data_.walletloginrequest_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void LoginRequest::unsafe_arena_set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest) {
- clear_data();
- if (walletloginrequest) {
- set_has_walletloginrequest();
- data_.walletloginrequest_ = walletloginrequest;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginRequest.walletLoginRequest)
-}
-inline ::identity::WalletLoginRequest* LoginRequest::_internal_mutable_walletloginrequest() {
- if (!_internal_has_walletloginrequest()) {
- clear_data();
- set_has_walletloginrequest();
- data_.walletloginrequest_ = CreateMaybeMessage< ::identity::WalletLoginRequest >(GetArena());
- }
- return data_.walletloginrequest_;
-}
-inline ::identity::WalletLoginRequest* LoginRequest::mutable_walletloginrequest() {
- // @@protoc_insertion_point(field_mutable:identity.LoginRequest.walletLoginRequest)
- return _internal_mutable_walletloginrequest();
-}
-
-inline bool LoginRequest::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void LoginRequest::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline LoginRequest::DataCase LoginRequest::data_case() const {
- return LoginRequest::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// LoginResponse
-
-// .identity.PakeLoginResponse pakeLoginResponse = 1;
-inline bool LoginResponse::_internal_has_pakeloginresponse() const {
- return data_case() == kPakeLoginResponse;
-}
-inline bool LoginResponse::has_pakeloginresponse() const {
- return _internal_has_pakeloginresponse();
-}
-inline void LoginResponse::set_has_pakeloginresponse() {
- _oneof_case_[0] = kPakeLoginResponse;
-}
-inline void LoginResponse::clear_pakeloginresponse() {
- if (_internal_has_pakeloginresponse()) {
- if (GetArena() == nullptr) {
- delete data_.pakeloginresponse_;
- }
- clear_has_data();
- }
-}
-inline ::identity::PakeLoginResponse* LoginResponse::release_pakeloginresponse() {
- // @@protoc_insertion_point(field_release:identity.LoginResponse.pakeLoginResponse)
- if (_internal_has_pakeloginresponse()) {
- clear_has_data();
- ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.pakeloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::PakeLoginResponse& LoginResponse::_internal_pakeloginresponse() const {
- return _internal_has_pakeloginresponse()
- ? *data_.pakeloginresponse_
- : reinterpret_cast< ::identity::PakeLoginResponse&>(::identity::_PakeLoginResponse_default_instance_);
-}
-inline const ::identity::PakeLoginResponse& LoginResponse::pakeloginresponse() const {
- // @@protoc_insertion_point(field_get:identity.LoginResponse.pakeLoginResponse)
- return _internal_pakeloginresponse();
-}
-inline ::identity::PakeLoginResponse* LoginResponse::unsafe_arena_release_pakeloginresponse() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginResponse.pakeLoginResponse)
- if (_internal_has_pakeloginresponse()) {
- clear_has_data();
- ::identity::PakeLoginResponse* temp = data_.pakeloginresponse_;
- data_.pakeloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void LoginResponse::unsafe_arena_set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
- clear_data();
- if (pakeloginresponse) {
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = pakeloginresponse;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginResponse.pakeLoginResponse)
-}
-inline ::identity::PakeLoginResponse* LoginResponse::_internal_mutable_pakeloginresponse() {
- if (!_internal_has_pakeloginresponse()) {
- clear_data();
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = CreateMaybeMessage< ::identity::PakeLoginResponse >(GetArena());
- }
- return data_.pakeloginresponse_;
-}
-inline ::identity::PakeLoginResponse* LoginResponse::mutable_pakeloginresponse() {
- // @@protoc_insertion_point(field_mutable:identity.LoginResponse.pakeLoginResponse)
- return _internal_mutable_pakeloginresponse();
-}
-
-// .identity.WalletLoginResponse walletLoginResponse = 2;
-inline bool LoginResponse::_internal_has_walletloginresponse() const {
- return data_case() == kWalletLoginResponse;
-}
-inline bool LoginResponse::has_walletloginresponse() const {
- return _internal_has_walletloginresponse();
-}
-inline void LoginResponse::set_has_walletloginresponse() {
- _oneof_case_[0] = kWalletLoginResponse;
-}
-inline void LoginResponse::clear_walletloginresponse() {
- if (_internal_has_walletloginresponse()) {
- if (GetArena() == nullptr) {
- delete data_.walletloginresponse_;
- }
- clear_has_data();
- }
-}
-inline ::identity::WalletLoginResponse* LoginResponse::release_walletloginresponse() {
- // @@protoc_insertion_point(field_release:identity.LoginResponse.walletLoginResponse)
- if (_internal_has_walletloginresponse()) {
- clear_has_data();
- ::identity::WalletLoginResponse* temp = data_.walletloginresponse_;
- if (GetArena() != nullptr) {
- temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
- }
- data_.walletloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline const ::identity::WalletLoginResponse& LoginResponse::_internal_walletloginresponse() const {
- return _internal_has_walletloginresponse()
- ? *data_.walletloginresponse_
- : reinterpret_cast< ::identity::WalletLoginResponse&>(::identity::_WalletLoginResponse_default_instance_);
-}
-inline const ::identity::WalletLoginResponse& LoginResponse::walletloginresponse() const {
- // @@protoc_insertion_point(field_get:identity.LoginResponse.walletLoginResponse)
- return _internal_walletloginresponse();
-}
-inline ::identity::WalletLoginResponse* LoginResponse::unsafe_arena_release_walletloginresponse() {
- // @@protoc_insertion_point(field_unsafe_arena_release:identity.LoginResponse.walletLoginResponse)
- if (_internal_has_walletloginresponse()) {
- clear_has_data();
- ::identity::WalletLoginResponse* temp = data_.walletloginresponse_;
- data_.walletloginresponse_ = nullptr;
- return temp;
- } else {
- return nullptr;
- }
-}
-inline void LoginResponse::unsafe_arena_set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse) {
- clear_data();
- if (walletloginresponse) {
- set_has_walletloginresponse();
- data_.walletloginresponse_ = walletloginresponse;
- }
- // @@protoc_insertion_point(field_unsafe_arena_set_allocated:identity.LoginResponse.walletLoginResponse)
-}
-inline ::identity::WalletLoginResponse* LoginResponse::_internal_mutable_walletloginresponse() {
- if (!_internal_has_walletloginresponse()) {
- clear_data();
- set_has_walletloginresponse();
- data_.walletloginresponse_ = CreateMaybeMessage< ::identity::WalletLoginResponse >(GetArena());
- }
- return data_.walletloginresponse_;
-}
-inline ::identity::WalletLoginResponse* LoginResponse::mutable_walletloginresponse() {
- // @@protoc_insertion_point(field_mutable:identity.LoginResponse.walletLoginResponse)
- return _internal_mutable_walletloginresponse();
-}
-
-inline bool LoginResponse::has_data() const {
- return data_case() != DATA_NOT_SET;
-}
-inline void LoginResponse::clear_has_data() {
- _oneof_case_[0] = DATA_NOT_SET;
-}
-inline LoginResponse::DataCase LoginResponse::data_case() const {
- return LoginResponse::DataCase(_oneof_case_[0]);
-}
-// -------------------------------------------------------------------
-
-// VerifyUserTokenRequest
-
-// string userID = 1;
-inline void VerifyUserTokenRequest::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& VerifyUserTokenRequest::userid() const {
- // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.userID)
- return _internal_userid();
-}
-inline void VerifyUserTokenRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.userID)
-}
-inline std::string* VerifyUserTokenRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.userID)
- return _internal_mutable_userid();
-}
-inline const std::string& VerifyUserTokenRequest::_internal_userid() const {
- return userid_.Get();
-}
-inline void VerifyUserTokenRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void VerifyUserTokenRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.userID)
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
-}
-inline std::string* VerifyUserTokenRequest::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* VerifyUserTokenRequest::release_userid() {
- // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.userID)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.userID)
-}
-
-// string deviceID = 2;
-inline void VerifyUserTokenRequest::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& VerifyUserTokenRequest::deviceid() const {
- // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.deviceID)
- return _internal_deviceid();
-}
-inline void VerifyUserTokenRequest::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.deviceID)
-}
-inline std::string* VerifyUserTokenRequest::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& VerifyUserTokenRequest::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void VerifyUserTokenRequest::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void VerifyUserTokenRequest::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.deviceID)
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
-}
-inline std::string* VerifyUserTokenRequest::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* VerifyUserTokenRequest::release_deviceid() {
- // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void VerifyUserTokenRequest::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:identity.VerifyUserTokenRequest.deviceID)
-}
-
-// string accessToken = 3;
-inline void VerifyUserTokenRequest::clear_accesstoken() {
- accesstoken_.ClearToEmpty();
-}
-inline const std::string& VerifyUserTokenRequest::accesstoken() const {
- // @@protoc_insertion_point(field_get:identity.VerifyUserTokenRequest.accessToken)
- return _internal_accesstoken();
-}
-inline void VerifyUserTokenRequest::set_accesstoken(const std::string& value) {
- _internal_set_accesstoken(value);
- // @@protoc_insertion_point(field_set:identity.VerifyUserTokenRequest.accessToken)
-}
-inline std::string* VerifyUserTokenRequest::mutable_accesstoken() {
- // @@protoc_insertion_point(field_mutable:identity.VerifyUserTokenRequest.accessToken)
- return _internal_mutable_accesstoken();
-}
-inline const std::string& VerifyUserTokenRequest::_internal_accesstoken() const {
- return accesstoken_.Get();
-}
-inline void VerifyUserTokenRequest::_internal_set_accesstoken(const std::string& value) {
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void VerifyUserTokenRequest::set_accesstoken(std::string&& value) {
-
- accesstoken_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.VerifyUserTokenRequest.accessToken)
-}
-inline void VerifyUserTokenRequest::set_accesstoken(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.VerifyUserTokenRequest.accessToken)
-}
-inline void VerifyUserTokenRequest::set_accesstoken(const char* value,
- size_t size) {
-
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.VerifyUserTokenRequest.accessToken)
-}
-inline std::string* VerifyUserTokenRequest::_internal_mutable_accesstoken() {
-
- return accesstoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* VerifyUserTokenRequest::release_accesstoken() {
- // @@protoc_insertion_point(field_release:identity.VerifyUserTokenRequest.accessToken)
- return accesstoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void VerifyUserTokenRequest::set_allocated_accesstoken(std::string* accesstoken) {
- if (accesstoken != nullptr) {
-
- } else {
-
- }
- accesstoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), accesstoken,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.VerifyUserTokenRequest.accessToken)
-}
-
-// -------------------------------------------------------------------
-
-// VerifyUserTokenResponse
-
-// bool tokenValid = 1;
-inline void VerifyUserTokenResponse::clear_tokenvalid() {
- tokenvalid_ = false;
-}
-inline bool VerifyUserTokenResponse::_internal_tokenvalid() const {
- return tokenvalid_;
-}
-inline bool VerifyUserTokenResponse::tokenvalid() const {
- // @@protoc_insertion_point(field_get:identity.VerifyUserTokenResponse.tokenValid)
- return _internal_tokenvalid();
-}
-inline void VerifyUserTokenResponse::_internal_set_tokenvalid(bool value) {
-
- tokenvalid_ = value;
-}
-inline void VerifyUserTokenResponse::set_tokenvalid(bool value) {
- _internal_set_tokenvalid(value);
- // @@protoc_insertion_point(field_set:identity.VerifyUserTokenResponse.tokenValid)
-}
-
-// -------------------------------------------------------------------
-
-// GetUserIDRequest
-
-// .identity.GetUserIDRequest.AuthType authType = 1;
-inline void GetUserIDRequest::clear_authtype() {
- authtype_ = 0;
-}
-inline ::identity::GetUserIDRequest_AuthType GetUserIDRequest::_internal_authtype() const {
- return static_cast< ::identity::GetUserIDRequest_AuthType >(authtype_);
-}
-inline ::identity::GetUserIDRequest_AuthType GetUserIDRequest::authtype() const {
- // @@protoc_insertion_point(field_get:identity.GetUserIDRequest.authType)
- return _internal_authtype();
-}
-inline void GetUserIDRequest::_internal_set_authtype(::identity::GetUserIDRequest_AuthType value) {
-
- authtype_ = value;
-}
-inline void GetUserIDRequest::set_authtype(::identity::GetUserIDRequest_AuthType value) {
- _internal_set_authtype(value);
- // @@protoc_insertion_point(field_set:identity.GetUserIDRequest.authType)
-}
-
-// string userInfo = 2;
-inline void GetUserIDRequest::clear_userinfo() {
- userinfo_.ClearToEmpty();
-}
-inline const std::string& GetUserIDRequest::userinfo() const {
- // @@protoc_insertion_point(field_get:identity.GetUserIDRequest.userInfo)
- return _internal_userinfo();
-}
-inline void GetUserIDRequest::set_userinfo(const std::string& value) {
- _internal_set_userinfo(value);
- // @@protoc_insertion_point(field_set:identity.GetUserIDRequest.userInfo)
-}
-inline std::string* GetUserIDRequest::mutable_userinfo() {
- // @@protoc_insertion_point(field_mutable:identity.GetUserIDRequest.userInfo)
- return _internal_mutable_userinfo();
-}
-inline const std::string& GetUserIDRequest::_internal_userinfo() const {
- return userinfo_.Get();
-}
-inline void GetUserIDRequest::_internal_set_userinfo(const std::string& value) {
-
- userinfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void GetUserIDRequest::set_userinfo(std::string&& value) {
-
- userinfo_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.GetUserIDRequest.userInfo)
-}
-inline void GetUserIDRequest::set_userinfo(const char* value) {
- GOOGLE_DCHECK(value != nullptr);
-
- userinfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
- // @@protoc_insertion_point(field_set_char:identity.GetUserIDRequest.userInfo)
-}
-inline void GetUserIDRequest::set_userinfo(const char* value,
- size_t size) {
-
- userinfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
- reinterpret_cast<const char*>(value), size), GetArena());
- // @@protoc_insertion_point(field_set_pointer:identity.GetUserIDRequest.userInfo)
-}
-inline std::string* GetUserIDRequest::_internal_mutable_userinfo() {
-
- return userinfo_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* GetUserIDRequest::release_userinfo() {
- // @@protoc_insertion_point(field_release:identity.GetUserIDRequest.userInfo)
- return userinfo_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GetUserIDRequest::set_allocated_userinfo(std::string* userinfo) {
- if (userinfo != nullptr) {
-
- } else {
-
- }
- userinfo_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), userinfo,
- GetArena());
- // @@protoc_insertion_point(field_set_allocated:identity.GetUserIDRequest.userInfo)
-}
-
-// -------------------------------------------------------------------
-
-// GetUserIDResponse
-
-// string userID = 1;
-inline void GetUserIDResponse::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& GetUserIDResponse::userid() const {
- // @@protoc_insertion_point(field_get:identity.GetUserIDResponse.userID)
- return _internal_userid();
-}
-inline void GetUserIDResponse::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.GetUserIDResponse.userID)
-}
-inline std::string* GetUserIDResponse::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.GetUserIDResponse.userID)
- return _internal_mutable_userid();
-}
-inline const std::string& GetUserIDResponse::_internal_userid() const {
- return userid_.Get();
-}
-inline void GetUserIDResponse::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void GetUserIDResponse::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.GetUserIDResponse.userID)
-}
-inline void GetUserIDResponse::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:identity.GetUserIDResponse.userID)
-}
-inline void GetUserIDResponse::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:identity.GetUserIDResponse.userID)
-}
-inline std::string* GetUserIDResponse::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* GetUserIDResponse::release_userid() {
- // @@protoc_insertion_point(field_release:identity.GetUserIDResponse.userID)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GetUserIDResponse::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:identity.GetUserIDResponse.userID)
-}
-
-// -------------------------------------------------------------------
-
-// GetUserPublicKeyRequest
-
-// string userID = 1;
-inline void GetUserPublicKeyRequest::clear_userid() {
- userid_.ClearToEmpty();
-}
-inline const std::string& GetUserPublicKeyRequest::userid() const {
- // @@protoc_insertion_point(field_get:identity.GetUserPublicKeyRequest.userID)
- return _internal_userid();
-}
-inline void GetUserPublicKeyRequest::set_userid(const std::string& value) {
- _internal_set_userid(value);
- // @@protoc_insertion_point(field_set:identity.GetUserPublicKeyRequest.userID)
-}
-inline std::string* GetUserPublicKeyRequest::mutable_userid() {
- // @@protoc_insertion_point(field_mutable:identity.GetUserPublicKeyRequest.userID)
- return _internal_mutable_userid();
-}
-inline const std::string& GetUserPublicKeyRequest::_internal_userid() const {
- return userid_.Get();
-}
-inline void GetUserPublicKeyRequest::_internal_set_userid(const std::string& value) {
-
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void GetUserPublicKeyRequest::set_userid(std::string&& value) {
-
- userid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.GetUserPublicKeyRequest.userID)
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.userID)
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.userID)
-}
-inline std::string* GetUserPublicKeyRequest::_internal_mutable_userid() {
-
- return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* GetUserPublicKeyRequest::release_userid() {
- // @@protoc_insertion_point(field_release:identity.GetUserPublicKeyRequest.userID)
- return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.userID)
-}
-
-// string deviceID = 2;
-inline void GetUserPublicKeyRequest::clear_deviceid() {
- deviceid_.ClearToEmpty();
-}
-inline const std::string& GetUserPublicKeyRequest::deviceid() const {
- // @@protoc_insertion_point(field_get:identity.GetUserPublicKeyRequest.deviceID)
- return _internal_deviceid();
-}
-inline void GetUserPublicKeyRequest::set_deviceid(const std::string& value) {
- _internal_set_deviceid(value);
- // @@protoc_insertion_point(field_set:identity.GetUserPublicKeyRequest.deviceID)
-}
-inline std::string* GetUserPublicKeyRequest::mutable_deviceid() {
- // @@protoc_insertion_point(field_mutable:identity.GetUserPublicKeyRequest.deviceID)
- return _internal_mutable_deviceid();
-}
-inline const std::string& GetUserPublicKeyRequest::_internal_deviceid() const {
- return deviceid_.Get();
-}
-inline void GetUserPublicKeyRequest::_internal_set_deviceid(const std::string& value) {
-
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void GetUserPublicKeyRequest::set_deviceid(std::string&& value) {
-
- deviceid_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.GetUserPublicKeyRequest.deviceID)
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.deviceID)
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.deviceID)
-}
-inline std::string* GetUserPublicKeyRequest::_internal_mutable_deviceid() {
-
- return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* GetUserPublicKeyRequest::release_deviceid() {
- // @@protoc_insertion_point(field_release:identity.GetUserPublicKeyRequest.deviceID)
- return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GetUserPublicKeyRequest::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:identity.GetUserPublicKeyRequest.deviceID)
-}
-
-// -------------------------------------------------------------------
-
-// GetUserPublicKeyResponse
-
-// string publicKey = 1;
-inline void GetUserPublicKeyResponse::clear_publickey() {
- publickey_.ClearToEmpty();
-}
-inline const std::string& GetUserPublicKeyResponse::publickey() const {
- // @@protoc_insertion_point(field_get:identity.GetUserPublicKeyResponse.publicKey)
- return _internal_publickey();
-}
-inline void GetUserPublicKeyResponse::set_publickey(const std::string& value) {
- _internal_set_publickey(value);
- // @@protoc_insertion_point(field_set:identity.GetUserPublicKeyResponse.publicKey)
-}
-inline std::string* GetUserPublicKeyResponse::mutable_publickey() {
- // @@protoc_insertion_point(field_mutable:identity.GetUserPublicKeyResponse.publicKey)
- return _internal_mutable_publickey();
-}
-inline const std::string& GetUserPublicKeyResponse::_internal_publickey() const {
- return publickey_.Get();
-}
-inline void GetUserPublicKeyResponse::_internal_set_publickey(const std::string& value) {
-
- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
-}
-inline void GetUserPublicKeyResponse::set_publickey(std::string&& value) {
-
- publickey_.Set(
- ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
- // @@protoc_insertion_point(field_set_rvalue:identity.GetUserPublicKeyResponse.publicKey)
-}
-inline void GetUserPublicKeyResponse::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:identity.GetUserPublicKeyResponse.publicKey)
-}
-inline void GetUserPublicKeyResponse::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:identity.GetUserPublicKeyResponse.publicKey)
-}
-inline std::string* GetUserPublicKeyResponse::_internal_mutable_publickey() {
-
- return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
-}
-inline std::string* GetUserPublicKeyResponse::release_publickey() {
- // @@protoc_insertion_point(field_release:identity.GetUserPublicKeyResponse.publicKey)
- return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-inline void GetUserPublicKeyResponse::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:identity.GetUserPublicKeyResponse.publicKey)
-}
-
-#ifdef __GNUC__
- #pragma GCC diagnostic pop
-#endif // __GNUC__
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-// -------------------------------------------------------------------
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-} // namespace identity
-
-PROTOBUF_NAMESPACE_OPEN
-
-template <> struct is_proto_enum< ::identity::GetUserIDRequest_AuthType> : ::std::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::identity::GetUserIDRequest_AuthType>() {
- return ::identity::GetUserIDRequest_AuthType_descriptor();
-}
-
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-
-#include <google/protobuf/port_undef.inc>
-#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_identity_2eproto
diff --git a/shared/protos/_generated/identity.pb.cc b/shared/protos/_generated/identity.pb.cc
deleted file mode 100644
--- a/shared/protos/_generated/identity.pb.cc
+++ /dev/null
@@ -1,5129 +0,0 @@
-// @generated by the protocol buffer compiler. DO NOT EDIT!
-// source: identity.proto
-
-#include "identity.pb.h"
-
-#include <algorithm>
-
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/wire_format_lite.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/wire_format.h>
-// @@protoc_insertion_point(includes)
-#include <google/protobuf/port_def.inc>
-
-PROTOBUF_PRAGMA_INIT_SEG
-namespace identity {
-constexpr PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , pakeregistrationrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , userpublickey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PakeRegistrationRequestAndUserIDDefaultTypeInternal {
- constexpr PakeRegistrationRequestAndUserIDDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PakeRegistrationRequestAndUserIDDefaultTypeInternal() {}
- union {
- PakeRegistrationRequestAndUserID _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeRegistrationRequestAndUserIDDefaultTypeInternal _PakeRegistrationRequestAndUserID_default_instance_;
-constexpr PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , pakecredentialrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , userpublickey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PakeCredentialRequestAndUserIDDefaultTypeInternal {
- constexpr PakeCredentialRequestAndUserIDDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PakeCredentialRequestAndUserIDDefaultTypeInternal() {}
- union {
- PakeCredentialRequestAndUserID _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeCredentialRequestAndUserIDDefaultTypeInternal _PakeCredentialRequestAndUserID_default_instance_;
-constexpr PakeLoginRequest::PakeLoginRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct PakeLoginRequestDefaultTypeInternal {
- constexpr PakeLoginRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PakeLoginRequestDefaultTypeInternal() {}
- union {
- PakeLoginRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeLoginRequestDefaultTypeInternal _PakeLoginRequest_default_instance_;
-constexpr PakeLoginResponse::PakeLoginResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct PakeLoginResponseDefaultTypeInternal {
- constexpr PakeLoginResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PakeLoginResponseDefaultTypeInternal() {}
- union {
- PakeLoginResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeLoginResponseDefaultTypeInternal _PakeLoginResponse_default_instance_;
-constexpr PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : pakeregistrationupload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , pakecredentialrequest_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal {
- constexpr PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal() {}
- union {
- PakeRegistrationUploadAndCredentialRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PakeRegistrationUploadAndCredentialRequestDefaultTypeInternal _PakeRegistrationUploadAndCredentialRequest_default_instance_;
-constexpr WalletLoginRequest::WalletLoginRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , siwemessage_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , siwesignature_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , userpublickey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct WalletLoginRequestDefaultTypeInternal {
- constexpr WalletLoginRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~WalletLoginRequestDefaultTypeInternal() {}
- union {
- WalletLoginRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletLoginRequestDefaultTypeInternal _WalletLoginRequest_default_instance_;
-constexpr WalletLoginResponse::WalletLoginResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : accesstoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct WalletLoginResponseDefaultTypeInternal {
- constexpr WalletLoginResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~WalletLoginResponseDefaultTypeInternal() {}
- union {
- WalletLoginResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WalletLoginResponseDefaultTypeInternal _WalletLoginResponse_default_instance_;
-constexpr RegistrationRequest::RegistrationRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct RegistrationRequestDefaultTypeInternal {
- constexpr RegistrationRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~RegistrationRequestDefaultTypeInternal() {}
- union {
- RegistrationRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RegistrationRequestDefaultTypeInternal _RegistrationRequest_default_instance_;
-constexpr RegistrationResponse::RegistrationResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct RegistrationResponseDefaultTypeInternal {
- constexpr RegistrationResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~RegistrationResponseDefaultTypeInternal() {}
- union {
- RegistrationResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RegistrationResponseDefaultTypeInternal _RegistrationResponse_default_instance_;
-constexpr LoginRequest::LoginRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct LoginRequestDefaultTypeInternal {
- constexpr LoginRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~LoginRequestDefaultTypeInternal() {}
- union {
- LoginRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
-constexpr LoginResponse::LoginResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : _oneof_case_{}{}
-struct LoginResponseDefaultTypeInternal {
- constexpr LoginResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~LoginResponseDefaultTypeInternal() {}
- union {
- LoginResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
-constexpr VerifyUserTokenRequest::VerifyUserTokenRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , accesstoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct VerifyUserTokenRequestDefaultTypeInternal {
- constexpr VerifyUserTokenRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~VerifyUserTokenRequestDefaultTypeInternal() {}
- union {
- VerifyUserTokenRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VerifyUserTokenRequestDefaultTypeInternal _VerifyUserTokenRequest_default_instance_;
-constexpr VerifyUserTokenResponse::VerifyUserTokenResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : tokenvalid_(false){}
-struct VerifyUserTokenResponseDefaultTypeInternal {
- constexpr VerifyUserTokenResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~VerifyUserTokenResponseDefaultTypeInternal() {}
- union {
- VerifyUserTokenResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT VerifyUserTokenResponseDefaultTypeInternal _VerifyUserTokenResponse_default_instance_;
-constexpr GetUserIDRequest::GetUserIDRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userinfo_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , authtype_(0)
-{}
-struct GetUserIDRequestDefaultTypeInternal {
- constexpr GetUserIDRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~GetUserIDRequestDefaultTypeInternal() {}
- union {
- GetUserIDRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetUserIDRequestDefaultTypeInternal _GetUserIDRequest_default_instance_;
-constexpr GetUserIDResponse::GetUserIDResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct GetUserIDResponseDefaultTypeInternal {
- constexpr GetUserIDResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~GetUserIDResponseDefaultTypeInternal() {}
- union {
- GetUserIDResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetUserIDResponseDefaultTypeInternal _GetUserIDResponse_default_instance_;
-constexpr GetUserPublicKeyRequest::GetUserPublicKeyRequest(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
- , deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct GetUserPublicKeyRequestDefaultTypeInternal {
- constexpr GetUserPublicKeyRequestDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~GetUserPublicKeyRequestDefaultTypeInternal() {}
- union {
- GetUserPublicKeyRequest _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetUserPublicKeyRequestDefaultTypeInternal _GetUserPublicKeyRequest_default_instance_;
-constexpr GetUserPublicKeyResponse::GetUserPublicKeyResponse(
- ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
- : publickey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
-struct GetUserPublicKeyResponseDefaultTypeInternal {
- constexpr GetUserPublicKeyResponseDefaultTypeInternal()
- : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
- ~GetUserPublicKeyResponseDefaultTypeInternal() {}
- union {
- GetUserPublicKeyResponse _instance;
- };
-};
-PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetUserPublicKeyResponseDefaultTypeInternal _GetUserPublicKeyResponse_default_instance_;
-} // namespace identity
-static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_identity_2eproto[17];
-static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_identity_2eproto[1];
-static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_identity_2eproto = nullptr;
-
-const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_identity_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, userid_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, deviceid_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, pakeregistrationrequest_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, username_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationRequestAndUserID, userpublickey_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, userid_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, deviceid_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, pakecredentialrequest_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeCredentialRequestAndUserID, userpublickey_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, _oneof_case_[0]),
- ~0u, // no _weak_field_map_
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginRequest, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, _oneof_case_[0]),
- ~0u, // no _weak_field_map_
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::identity::PakeLoginResponse, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, pakeregistrationupload_),
- PROTOBUF_FIELD_OFFSET(::identity::PakeRegistrationUploadAndCredentialRequest, pakecredentialrequest_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, deviceid_),
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, siwemessage_),
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, siwesignature_),
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginRequest, userpublickey_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginResponse, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::WalletLoginResponse, accesstoken_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::RegistrationRequest, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::RegistrationRequest, _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(::identity::RegistrationRequest, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, _oneof_case_[0]),
- ~0u, // no _weak_field_map_
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::identity::RegistrationResponse, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, _oneof_case_[0]),
- ~0u, // no _weak_field_map_
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::identity::LoginRequest, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, _internal_metadata_),
- ~0u, // no _extensions_
- PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, _oneof_case_[0]),
- ~0u, // no _weak_field_map_
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
- PROTOBUF_FIELD_OFFSET(::identity::LoginResponse, data_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, deviceid_),
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenRequest, accesstoken_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenResponse, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::VerifyUserTokenResponse, tokenvalid_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserIDRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserIDRequest, authtype_),
- PROTOBUF_FIELD_OFFSET(::identity::GetUserIDRequest, userinfo_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserIDResponse, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserIDResponse, userid_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserPublicKeyRequest, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserPublicKeyRequest, userid_),
- PROTOBUF_FIELD_OFFSET(::identity::GetUserPublicKeyRequest, deviceid_),
- ~0u, // no _has_bits_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserPublicKeyResponse, _internal_metadata_),
- ~0u, // no _extensions_
- ~0u, // no _oneof_case_
- ~0u, // no _weak_field_map_
- PROTOBUF_FIELD_OFFSET(::identity::GetUserPublicKeyResponse, publickey_),
-};
-static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
- { 0, -1, sizeof(::identity::PakeRegistrationRequestAndUserID)},
- { 10, -1, sizeof(::identity::PakeCredentialRequestAndUserID)},
- { 19, -1, sizeof(::identity::PakeLoginRequest)},
- { 27, -1, sizeof(::identity::PakeLoginResponse)},
- { 35, -1, sizeof(::identity::PakeRegistrationUploadAndCredentialRequest)},
- { 42, -1, sizeof(::identity::WalletLoginRequest)},
- { 52, -1, sizeof(::identity::WalletLoginResponse)},
- { 58, -1, sizeof(::identity::RegistrationRequest)},
- { 67, -1, sizeof(::identity::RegistrationResponse)},
- { 75, -1, sizeof(::identity::LoginRequest)},
- { 83, -1, sizeof(::identity::LoginResponse)},
- { 91, -1, sizeof(::identity::VerifyUserTokenRequest)},
- { 99, -1, sizeof(::identity::VerifyUserTokenResponse)},
- { 105, -1, sizeof(::identity::GetUserIDRequest)},
- { 112, -1, sizeof(::identity::GetUserIDResponse)},
- { 118, -1, sizeof(::identity::GetUserPublicKeyRequest)},
- { 125, -1, sizeof(::identity::GetUserPublicKeyResponse)},
-};
-
-static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeRegistrationRequestAndUserID_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeCredentialRequestAndUserID_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeLoginRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeLoginResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_PakeRegistrationUploadAndCredentialRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_WalletLoginRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_WalletLoginResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_RegistrationRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_RegistrationResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_LoginRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_LoginResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_VerifyUserTokenRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_VerifyUserTokenResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_GetUserIDRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_GetUserIDResponse_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_GetUserPublicKeyRequest_default_instance_),
- reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::identity::_GetUserPublicKeyResponse_default_instance_),
-};
-
-const char descriptor_table_protodef_identity_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
- "\n\016identity.proto\022\010identity\"\216\001\n PakeRegis"
- "trationRequestAndUserID\022\016\n\006userID\030\001 \001(\t\022"
- "\020\n\010deviceID\030\002 \001(\t\022\037\n\027pakeRegistrationReq"
- "uest\030\003 \001(\014\022\020\n\010username\030\004 \001(\t\022\025\n\ruserPubl"
- "icKey\030\005 \001(\t\"x\n\036PakeCredentialRequestAndU"
- "serID\022\016\n\006userID\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\t\022"
- "\035\n\025pakeCredentialRequest\030\003 \001(\014\022\025\n\ruserPu"
- "blicKey\030\004 \001(\t\"\224\001\n\020PakeLoginRequest\022R\n\036pa"
- "keCredentialRequestAndUserID\030\001 \001(\0132(.ide"
- "ntity.PakeCredentialRequestAndUserIDH\000\022$"
- "\n\032pakeCredentialFinalization\030\002 \001(\014H\000B\006\n\004"
- "data\"T\n\021PakeLoginResponse\022 \n\026pakeCredent"
- "ialResponse\030\001 \001(\014H\000\022\025\n\013accessToken\030\002 \001(\t"
- "H\000B\006\n\004data\"k\n*PakeRegistrationUploadAndC"
- "redentialRequest\022\036\n\026pakeRegistrationUplo"
- "ad\030\001 \001(\014\022\035\n\025pakeCredentialRequest\030\002 \001(\014\""
- "y\n\022WalletLoginRequest\022\016\n\006userID\030\001 \001(\t\022\020\n"
- "\010deviceID\030\002 \001(\t\022\023\n\013siweMessage\030\003 \001(\t\022\025\n\r"
- "siweSignature\030\004 \001(\014\022\025\n\ruserPublicKey\030\005 \001"
- "(\t\"*\n\023WalletLoginResponse\022\023\n\013accessToken"
- "\030\001 \001(\t\"\207\002\n\023RegistrationRequest\022V\n pakeRe"
- "gistrationRequestAndUserID\030\001 \001(\0132*.ident"
- "ity.PakeRegistrationRequestAndUserIDH\000\022j"
- "\n*pakeRegistrationUploadAndCredentialReq"
- "uest\030\002 \001(\01324.identity.PakeRegistrationUp"
- "loadAndCredentialRequestH\000\022$\n\032pakeCreden"
- "tialFinalization\030\003 \001(\014H\000B\006\n\004data\"|\n\024Regi"
- "strationResponse\022\"\n\030pakeRegistrationResp"
- "onse\030\001 \001(\014H\000\0228\n\021pakeLoginResponse\030\002 \001(\0132"
- "\033.identity.PakeLoginResponseH\000B\006\n\004data\"\212"
- "\001\n\014LoginRequest\0226\n\020pakeLoginRequest\030\001 \001("
- "\0132\032.identity.PakeLoginRequestH\000\022:\n\022walle"
- "tLoginRequest\030\002 \001(\0132\034.identity.WalletLog"
- "inRequestH\000B\006\n\004data\"\217\001\n\rLoginResponse\0228\n"
- "\021pakeLoginResponse\030\001 \001(\0132\033.identity.Pake"
- "LoginResponseH\000\022<\n\023walletLoginResponse\030\002"
- " \001(\0132\035.identity.WalletLoginResponseH\000B\006\n"
- "\004data\"O\n\026VerifyUserTokenRequest\022\016\n\006userI"
- "D\030\001 \001(\t\022\020\n\010deviceID\030\002 \001(\t\022\023\n\013accessToken"
- "\030\003 \001(\t\"-\n\027VerifyUserTokenResponse\022\022\n\ntok"
- "enValid\030\001 \001(\010\"\201\001\n\020GetUserIDRequest\0225\n\010au"
- "thType\030\001 \001(\0162#.identity.GetUserIDRequest"
- ".AuthType\022\020\n\010userInfo\030\002 \001(\t\"$\n\010AuthType\022"
- "\014\n\010PASSWORD\020\000\022\n\n\006WALLET\020\001\"#\n\021GetUserIDRe"
- "sponse\022\016\n\006userID\030\001 \001(\t\";\n\027GetUserPublicK"
- "eyRequest\022\016\n\006userID\030\001 \001(\t\022\020\n\010deviceID\030\002 "
- "\001(\t\"-\n\030GetUserPublicKeyResponse\022\021\n\tpubli"
- "cKey\030\001 \001(\t2\251\003\n\017IdentityService\022S\n\014Regist"
- "erUser\022\035.identity.RegistrationRequest\032\036."
- "identity.RegistrationResponse\"\000(\0010\001\022B\n\tL"
- "oginUser\022\026.identity.LoginRequest\032\027.ident"
- "ity.LoginResponse\"\000(\0010\001\022X\n\017VerifyUserTok"
- "en\022 .identity.VerifyUserTokenRequest\032!.i"
- "dentity.VerifyUserTokenResponse\"\000\022F\n\tGet"
- "UserID\022\032.identity.GetUserIDRequest\032\033.ide"
- "ntity.GetUserIDResponse\"\000\022[\n\020GetUserPubl"
- "icKey\022!.identity.GetUserPublicKeyRequest"
- "\032\".identity.GetUserPublicKeyResponse\"\000b\006"
- "proto3"
- ;
-static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_identity_2eproto_once;
-const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_identity_2eproto = {
- false, false, 2326, descriptor_table_protodef_identity_2eproto, "identity.proto",
- &descriptor_table_identity_2eproto_once, nullptr, 0, 17,
- schemas, file_default_instances, TableStruct_identity_2eproto::offsets,
- file_level_metadata_identity_2eproto, file_level_enum_descriptors_identity_2eproto, file_level_service_descriptors_identity_2eproto,
-};
-PROTOBUF_ATTRIBUTE_WEAK ::PROTOBUF_NAMESPACE_ID::Metadata
-descriptor_table_identity_2eproto_metadata_getter(int index) {
- ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_identity_2eproto);
- return descriptor_table_identity_2eproto.file_level_metadata[index];
-}
-
-// Force running AddDescriptors() at dynamic initialization time.
-PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_identity_2eproto(&descriptor_table_identity_2eproto);
-namespace identity {
-const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GetUserIDRequest_AuthType_descriptor() {
- ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_identity_2eproto);
- return file_level_enum_descriptors_identity_2eproto[0];
-}
-bool GetUserIDRequest_AuthType_IsValid(int value) {
- switch (value) {
- case 0:
- case 1:
- return true;
- default:
- return false;
- }
-}
-
-#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-constexpr GetUserIDRequest_AuthType GetUserIDRequest::PASSWORD;
-constexpr GetUserIDRequest_AuthType GetUserIDRequest::WALLET;
-constexpr GetUserIDRequest_AuthType GetUserIDRequest::AuthType_MIN;
-constexpr GetUserIDRequest_AuthType GetUserIDRequest::AuthType_MAX;
-constexpr int GetUserIDRequest::AuthType_ARRAYSIZE;
-#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
-
-// ===================================================================
-
-class PakeRegistrationRequestAndUserID::_Internal {
- public:
-};
-
-PakeRegistrationRequestAndUserID::PakeRegistrationRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.PakeRegistrationRequestAndUserID)
-}
-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());
- if (!from._internal_userid().empty()) {
- userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(),
- GetArena());
- }
- deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_deviceid().empty()) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
- 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());
- }
- username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_username().empty()) {
- username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(),
- GetArena());
- }
- userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userpublickey().empty()) {
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userpublickey(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.PakeRegistrationRequestAndUserID)
-}
-
-void PakeRegistrationRequestAndUserID::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-pakeregistrationrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-PakeRegistrationRequestAndUserID::~PakeRegistrationRequestAndUserID() {
- // @@protoc_insertion_point(destructor:identity.PakeRegistrationRequestAndUserID)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void PakeRegistrationRequestAndUserID::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- pakeregistrationrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- userpublickey_.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:identity.PakeRegistrationRequestAndUserID)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- deviceid_.ClearToEmpty();
- pakeregistrationrequest_.ClearToEmpty();
- username_.ClearToEmpty();
- userpublickey_.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, "identity.PakeRegistrationRequestAndUserID.userID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string deviceID = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_deviceid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeRegistrationRequestAndUserID.deviceID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes pakeRegistrationRequest = 3;
- case 3:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
- auto str = _internal_mutable_pakeregistrationrequest();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string username = 4;
- case 4:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
- auto str = _internal_mutable_username();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeRegistrationRequestAndUserID.username"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string userPublicKey = 5;
- case 5:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
- auto str = _internal_mutable_userpublickey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeRegistrationRequestAndUserID.userPublicKey"));
- 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:identity.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,
- "identity.PakeRegistrationRequestAndUserID.userID");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeRegistrationRequestAndUserID.deviceID");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_deviceid(), target);
- }
-
- // bytes pakeRegistrationRequest = 3;
- if (this->pakeregistrationrequest().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 3, this->_internal_pakeregistrationrequest(), target);
- }
-
- // string username = 4;
- if (this->username().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeRegistrationRequestAndUserID.username");
- target = stream->WriteStringMaybeAliased(
- 4, this->_internal_username(), target);
- }
-
- // string userPublicKey = 5;
- if (this->userpublickey().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userpublickey().data(), static_cast<int>(this->_internal_userpublickey().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeRegistrationRequestAndUserID.userPublicKey");
- target = stream->WriteStringMaybeAliased(
- 5, this->_internal_userpublickey(), 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:identity.PakeRegistrationRequestAndUserID)
- return target;
-}
-
-size_t PakeRegistrationRequestAndUserID::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.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());
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_deviceid());
- }
-
- // bytes pakeRegistrationRequest = 3;
- if (this->pakeregistrationrequest().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakeregistrationrequest());
- }
-
- // string username = 4;
- if (this->username().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_username());
- }
-
- // string userPublicKey = 5;
- if (this->userpublickey().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userpublickey());
- }
-
- 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:identity.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:identity.PakeRegistrationRequestAndUserID)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeRegistrationRequestAndUserID)
- MergeFrom(*source);
- }
-}
-
-void PakeRegistrationRequestAndUserID::MergeFrom(const PakeRegistrationRequestAndUserID& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.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.deviceid().size() > 0) {
- _internal_set_deviceid(from._internal_deviceid());
- }
- if (from.pakeregistrationrequest().size() > 0) {
- _internal_set_pakeregistrationrequest(from._internal_pakeregistrationrequest());
- }
- if (from.username().size() > 0) {
- _internal_set_username(from._internal_username());
- }
- if (from.userpublickey().size() > 0) {
- _internal_set_userpublickey(from._internal_userpublickey());
- }
-}
-
-void PakeRegistrationRequestAndUserID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeRegistrationRequestAndUserID)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void PakeRegistrationRequestAndUserID::CopyFrom(const PakeRegistrationRequestAndUserID& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.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());
- deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- pakeregistrationrequest_.Swap(&other->pakeregistrationrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- username_.Swap(&other->username_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- userpublickey_.Swap(&other->userpublickey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata PakeRegistrationRequestAndUserID::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class PakeCredentialRequestAndUserID::_Internal {
- public:
-};
-
-PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.PakeCredentialRequestAndUserID)
-}
-PakeCredentialRequestAndUserID::PakeCredentialRequestAndUserID(const PakeCredentialRequestAndUserID& 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());
- }
- deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_deviceid().empty()) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
- GetArena());
- }
- pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_pakecredentialrequest().empty()) {
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakecredentialrequest(),
- GetArena());
- }
- userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userpublickey().empty()) {
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userpublickey(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.PakeCredentialRequestAndUserID)
-}
-
-void PakeCredentialRequestAndUserID::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-PakeCredentialRequestAndUserID::~PakeCredentialRequestAndUserID() {
- // @@protoc_insertion_point(destructor:identity.PakeCredentialRequestAndUserID)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void PakeCredentialRequestAndUserID::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- pakecredentialrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- userpublickey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void PakeCredentialRequestAndUserID::ArenaDtor(void* object) {
- PakeCredentialRequestAndUserID* _this = reinterpret_cast< PakeCredentialRequestAndUserID* >(object);
- (void)_this;
-}
-void PakeCredentialRequestAndUserID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void PakeCredentialRequestAndUserID::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void PakeCredentialRequestAndUserID::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.PakeCredentialRequestAndUserID)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- deviceid_.ClearToEmpty();
- pakecredentialrequest_.ClearToEmpty();
- userpublickey_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* PakeCredentialRequestAndUserID::_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, "identity.PakeCredentialRequestAndUserID.userID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string deviceID = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_deviceid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeCredentialRequestAndUserID.deviceID"));
- 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;
- // string userPublicKey = 4;
- case 4:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
- auto str = _internal_mutable_userpublickey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeCredentialRequestAndUserID.userPublicKey"));
- 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* PakeCredentialRequestAndUserID::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.PakeCredentialRequestAndUserID)
- ::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,
- "identity.PakeCredentialRequestAndUserID.userID");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeCredentialRequestAndUserID.deviceID");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_deviceid(), target);
- }
-
- // bytes pakeCredentialRequest = 3;
- if (this->pakecredentialrequest().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 3, this->_internal_pakecredentialrequest(), target);
- }
-
- // string userPublicKey = 4;
- if (this->userpublickey().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userpublickey().data(), static_cast<int>(this->_internal_userpublickey().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeCredentialRequestAndUserID.userPublicKey");
- target = stream->WriteStringMaybeAliased(
- 4, this->_internal_userpublickey(), 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:identity.PakeCredentialRequestAndUserID)
- return target;
-}
-
-size_t PakeCredentialRequestAndUserID::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.PakeCredentialRequestAndUserID)
- 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 deviceID = 2;
- if (this->deviceid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_deviceid());
- }
-
- // bytes pakeCredentialRequest = 3;
- if (this->pakecredentialrequest().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakecredentialrequest());
- }
-
- // string userPublicKey = 4;
- if (this->userpublickey().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userpublickey());
- }
-
- 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 PakeCredentialRequestAndUserID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeCredentialRequestAndUserID)
- GOOGLE_DCHECK_NE(&from, this);
- const PakeCredentialRequestAndUserID* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeCredentialRequestAndUserID>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeCredentialRequestAndUserID)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeCredentialRequestAndUserID)
- MergeFrom(*source);
- }
-}
-
-void PakeCredentialRequestAndUserID::MergeFrom(const PakeCredentialRequestAndUserID& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeCredentialRequestAndUserID)
- 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.deviceid().size() > 0) {
- _internal_set_deviceid(from._internal_deviceid());
- }
- if (from.pakecredentialrequest().size() > 0) {
- _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
- }
- if (from.userpublickey().size() > 0) {
- _internal_set_userpublickey(from._internal_userpublickey());
- }
-}
-
-void PakeCredentialRequestAndUserID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeCredentialRequestAndUserID)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void PakeCredentialRequestAndUserID::CopyFrom(const PakeCredentialRequestAndUserID& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeCredentialRequestAndUserID)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool PakeCredentialRequestAndUserID::IsInitialized() const {
- return true;
-}
-
-void PakeCredentialRequestAndUserID::InternalSwap(PakeCredentialRequestAndUserID* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- pakecredentialrequest_.Swap(&other->pakecredentialrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- userpublickey_.Swap(&other->userpublickey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata PakeCredentialRequestAndUserID::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class PakeLoginRequest::_Internal {
- public:
- static const ::identity::PakeCredentialRequestAndUserID& pakecredentialrequestanduserid(const PakeLoginRequest* msg);
-};
-
-const ::identity::PakeCredentialRequestAndUserID&
-PakeLoginRequest::_Internal::pakecredentialrequestanduserid(const PakeLoginRequest* msg) {
- return *msg->data_.pakecredentialrequestanduserid_;
-}
-void PakeLoginRequest::set_allocated_pakecredentialrequestanduserid(::identity::PakeCredentialRequestAndUserID* pakecredentialrequestanduserid) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (pakecredentialrequestanduserid) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakecredentialrequestanduserid);
- if (message_arena != submessage_arena) {
- pakecredentialrequestanduserid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, pakecredentialrequestanduserid, submessage_arena);
- }
- set_has_pakecredentialrequestanduserid();
- data_.pakecredentialrequestanduserid_ = pakecredentialrequestanduserid;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.PakeLoginRequest.pakeCredentialRequestAndUserID)
-}
-PakeLoginRequest::PakeLoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.PakeLoginRequest)
-}
-PakeLoginRequest::PakeLoginRequest(const PakeLoginRequest& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- clear_has_data();
- switch (from.data_case()) {
- case kPakeCredentialRequestAndUserID: {
- _internal_mutable_pakecredentialrequestanduserid()->::identity::PakeCredentialRequestAndUserID::MergeFrom(from._internal_pakecredentialrequestanduserid());
- break;
- }
- case kPakeCredentialFinalization: {
- _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.PakeLoginRequest)
-}
-
-void PakeLoginRequest::SharedCtor() {
-clear_has_data();
-}
-
-PakeLoginRequest::~PakeLoginRequest() {
- // @@protoc_insertion_point(destructor:identity.PakeLoginRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void PakeLoginRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void PakeLoginRequest::ArenaDtor(void* object) {
- PakeLoginRequest* _this = reinterpret_cast< PakeLoginRequest* >(object);
- (void)_this;
-}
-void PakeLoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void PakeLoginRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void PakeLoginRequest::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.PakeLoginRequest)
- switch (data_case()) {
- case kPakeCredentialRequestAndUserID: {
- if (GetArena() == nullptr) {
- delete data_.pakecredentialrequestanduserid_;
- }
- break;
- }
- case kPakeCredentialFinalization: {
- data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void PakeLoginRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.PakeLoginRequest)
- ::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* PakeLoginRequest::_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) {
- // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- ptr = ctx->ParseMessage(_internal_mutable_pakecredentialrequestanduserid(), ptr);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes pakeCredentialFinalization = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_pakecredentialfinalization();
- 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* PakeLoginRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.PakeLoginRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
- if (_internal_has_pakecredentialrequestanduserid()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 1, _Internal::pakecredentialrequestanduserid(this), target, stream);
- }
-
- // bytes pakeCredentialFinalization = 2;
- if (_internal_has_pakecredentialfinalization()) {
- target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_pakecredentialfinalization(), 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:identity.PakeLoginRequest)
- return target;
-}
-
-size_t PakeLoginRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.PakeLoginRequest)
- 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()) {
- // .identity.PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
- case kPakeCredentialRequestAndUserID: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakecredentialrequestanduserid_);
- break;
- }
- // bytes pakeCredentialFinalization = 2;
- case kPakeCredentialFinalization: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakecredentialfinalization());
- 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 PakeLoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeLoginRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const PakeLoginRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeLoginRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeLoginRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeLoginRequest)
- MergeFrom(*source);
- }
-}
-
-void PakeLoginRequest::MergeFrom(const PakeLoginRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeLoginRequest)
- 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 kPakeCredentialRequestAndUserID: {
- _internal_mutable_pakecredentialrequestanduserid()->::identity::PakeCredentialRequestAndUserID::MergeFrom(from._internal_pakecredentialrequestanduserid());
- break;
- }
- case kPakeCredentialFinalization: {
- _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void PakeLoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeLoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void PakeLoginRequest::CopyFrom(const PakeLoginRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeLoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool PakeLoginRequest::IsInitialized() const {
- return true;
-}
-
-void PakeLoginRequest::InternalSwap(PakeLoginRequest* 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 PakeLoginRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class PakeLoginResponse::_Internal {
- public:
-};
-
-PakeLoginResponse::PakeLoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.PakeLoginResponse)
-}
-PakeLoginResponse::PakeLoginResponse(const PakeLoginResponse& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- clear_has_data();
- switch (from.data_case()) {
- case kPakeCredentialResponse: {
- _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
- break;
- }
- case kAccessToken: {
- _internal_set_accesstoken(from._internal_accesstoken());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.PakeLoginResponse)
-}
-
-void PakeLoginResponse::SharedCtor() {
-clear_has_data();
-}
-
-PakeLoginResponse::~PakeLoginResponse() {
- // @@protoc_insertion_point(destructor:identity.PakeLoginResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void PakeLoginResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void PakeLoginResponse::ArenaDtor(void* object) {
- PakeLoginResponse* _this = reinterpret_cast< PakeLoginResponse* >(object);
- (void)_this;
-}
-void PakeLoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void PakeLoginResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void PakeLoginResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.PakeLoginResponse)
- switch (data_case()) {
- case kPakeCredentialResponse: {
- data_.pakecredentialresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- break;
- }
- case kAccessToken: {
- data_.accesstoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void PakeLoginResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.PakeLoginResponse)
- ::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* PakeLoginResponse::_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 pakeCredentialResponse = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_pakecredentialresponse();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string accessToken = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_accesstoken();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.PakeLoginResponse.accessToken"));
- 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* PakeLoginResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.PakeLoginResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // bytes pakeCredentialResponse = 1;
- if (_internal_has_pakecredentialresponse()) {
- target = stream->WriteBytesMaybeAliased(
- 1, this->_internal_pakecredentialresponse(), target);
- }
-
- // string accessToken = 2;
- if (_internal_has_accesstoken()) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.PakeLoginResponse.accessToken");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_accesstoken(), 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:identity.PakeLoginResponse)
- return target;
-}
-
-size_t PakeLoginResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.PakeLoginResponse)
- 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 pakeCredentialResponse = 1;
- case kPakeCredentialResponse: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakecredentialresponse());
- break;
- }
- // string accessToken = 2;
- case kAccessToken: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_accesstoken());
- 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 PakeLoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeLoginResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const PakeLoginResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeLoginResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeLoginResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeLoginResponse)
- MergeFrom(*source);
- }
-}
-
-void PakeLoginResponse::MergeFrom(const PakeLoginResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeLoginResponse)
- 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 kPakeCredentialResponse: {
- _internal_set_pakecredentialresponse(from._internal_pakecredentialresponse());
- break;
- }
- case kAccessToken: {
- _internal_set_accesstoken(from._internal_accesstoken());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void PakeLoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeLoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void PakeLoginResponse::CopyFrom(const PakeLoginResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeLoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool PakeLoginResponse::IsInitialized() const {
- return true;
-}
-
-void PakeLoginResponse::InternalSwap(PakeLoginResponse* 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 PakeLoginResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class PakeRegistrationUploadAndCredentialRequest::_Internal {
- public:
-};
-
-PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.PakeRegistrationUploadAndCredentialRequest)
-}
-PakeRegistrationUploadAndCredentialRequest::PakeRegistrationUploadAndCredentialRequest(const PakeRegistrationUploadAndCredentialRequest& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_pakeregistrationupload().empty()) {
- pakeregistrationupload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakeregistrationupload(),
- GetArena());
- }
- pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_pakecredentialrequest().empty()) {
- pakecredentialrequest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pakecredentialrequest(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.PakeRegistrationUploadAndCredentialRequest)
-}
-
-void PakeRegistrationUploadAndCredentialRequest::SharedCtor() {
-pakeregistrationupload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-pakecredentialrequest_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-PakeRegistrationUploadAndCredentialRequest::~PakeRegistrationUploadAndCredentialRequest() {
- // @@protoc_insertion_point(destructor:identity.PakeRegistrationUploadAndCredentialRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void PakeRegistrationUploadAndCredentialRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- pakeregistrationupload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- pakecredentialrequest_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void PakeRegistrationUploadAndCredentialRequest::ArenaDtor(void* object) {
- PakeRegistrationUploadAndCredentialRequest* _this = reinterpret_cast< PakeRegistrationUploadAndCredentialRequest* >(object);
- (void)_this;
-}
-void PakeRegistrationUploadAndCredentialRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void PakeRegistrationUploadAndCredentialRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void PakeRegistrationUploadAndCredentialRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.PakeRegistrationUploadAndCredentialRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- pakeregistrationupload_.ClearToEmpty();
- pakecredentialrequest_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* PakeRegistrationUploadAndCredentialRequest::_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 pakeRegistrationUpload = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_pakeregistrationupload();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes pakeCredentialRequest = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_pakecredentialrequest();
- 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* PakeRegistrationUploadAndCredentialRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.PakeRegistrationUploadAndCredentialRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // bytes pakeRegistrationUpload = 1;
- if (this->pakeregistrationupload().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 1, this->_internal_pakeregistrationupload(), target);
- }
-
- // bytes pakeCredentialRequest = 2;
- if (this->pakecredentialrequest().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 2, this->_internal_pakecredentialrequest(), 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:identity.PakeRegistrationUploadAndCredentialRequest)
- return target;
-}
-
-size_t PakeRegistrationUploadAndCredentialRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.PakeRegistrationUploadAndCredentialRequest)
- 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 pakeRegistrationUpload = 1;
- if (this->pakeregistrationupload().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakeregistrationupload());
- }
-
- // bytes pakeCredentialRequest = 2;
- if (this->pakecredentialrequest().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakecredentialrequest());
- }
-
- 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 PakeRegistrationUploadAndCredentialRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const PakeRegistrationUploadAndCredentialRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<PakeRegistrationUploadAndCredentialRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.PakeRegistrationUploadAndCredentialRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.PakeRegistrationUploadAndCredentialRequest)
- MergeFrom(*source);
- }
-}
-
-void PakeRegistrationUploadAndCredentialRequest::MergeFrom(const PakeRegistrationUploadAndCredentialRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
- 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.pakeregistrationupload().size() > 0) {
- _internal_set_pakeregistrationupload(from._internal_pakeregistrationupload());
- }
- if (from.pakecredentialrequest().size() > 0) {
- _internal_set_pakecredentialrequest(from._internal_pakecredentialrequest());
- }
-}
-
-void PakeRegistrationUploadAndCredentialRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void PakeRegistrationUploadAndCredentialRequest::CopyFrom(const PakeRegistrationUploadAndCredentialRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.PakeRegistrationUploadAndCredentialRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool PakeRegistrationUploadAndCredentialRequest::IsInitialized() const {
- return true;
-}
-
-void PakeRegistrationUploadAndCredentialRequest::InternalSwap(PakeRegistrationUploadAndCredentialRequest* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- pakeregistrationupload_.Swap(&other->pakeregistrationupload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- pakecredentialrequest_.Swap(&other->pakecredentialrequest_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata PakeRegistrationUploadAndCredentialRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class WalletLoginRequest::_Internal {
- public:
-};
-
-WalletLoginRequest::WalletLoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.WalletLoginRequest)
-}
-WalletLoginRequest::WalletLoginRequest(const WalletLoginRequest& 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());
- }
- deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_deviceid().empty()) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
- GetArena());
- }
- siwemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_siwemessage().empty()) {
- siwemessage_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_siwemessage(),
- GetArena());
- }
- siwesignature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_siwesignature().empty()) {
- siwesignature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_siwesignature(),
- GetArena());
- }
- userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userpublickey().empty()) {
- userpublickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userpublickey(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.WalletLoginRequest)
-}
-
-void WalletLoginRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-siwemessage_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-siwesignature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-userpublickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-WalletLoginRequest::~WalletLoginRequest() {
- // @@protoc_insertion_point(destructor:identity.WalletLoginRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void WalletLoginRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- siwemessage_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- siwesignature_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- userpublickey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void WalletLoginRequest::ArenaDtor(void* object) {
- WalletLoginRequest* _this = reinterpret_cast< WalletLoginRequest* >(object);
- (void)_this;
-}
-void WalletLoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void WalletLoginRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void WalletLoginRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.WalletLoginRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- deviceid_.ClearToEmpty();
- siwemessage_.ClearToEmpty();
- siwesignature_.ClearToEmpty();
- userpublickey_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* WalletLoginRequest::_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, "identity.WalletLoginRequest.userID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string deviceID = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_deviceid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginRequest.deviceID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string siweMessage = 3;
- case 3:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
- auto str = _internal_mutable_siwemessage();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginRequest.siweMessage"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes siweSignature = 4;
- case 4:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
- auto str = _internal_mutable_siwesignature();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string userPublicKey = 5;
- case 5:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
- auto str = _internal_mutable_userpublickey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginRequest.userPublicKey"));
- 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* WalletLoginRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.WalletLoginRequest)
- ::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,
- "identity.WalletLoginRequest.userID");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.WalletLoginRequest.deviceID");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_deviceid(), target);
- }
-
- // string siweMessage = 3;
- if (this->siwemessage().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_siwemessage().data(), static_cast<int>(this->_internal_siwemessage().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.WalletLoginRequest.siweMessage");
- target = stream->WriteStringMaybeAliased(
- 3, this->_internal_siwemessage(), target);
- }
-
- // bytes siweSignature = 4;
- if (this->siwesignature().size() > 0) {
- target = stream->WriteBytesMaybeAliased(
- 4, this->_internal_siwesignature(), target);
- }
-
- // string userPublicKey = 5;
- if (this->userpublickey().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userpublickey().data(), static_cast<int>(this->_internal_userpublickey().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.WalletLoginRequest.userPublicKey");
- target = stream->WriteStringMaybeAliased(
- 5, this->_internal_userpublickey(), 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:identity.WalletLoginRequest)
- return target;
-}
-
-size_t WalletLoginRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.WalletLoginRequest)
- 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 deviceID = 2;
- if (this->deviceid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_deviceid());
- }
-
- // string siweMessage = 3;
- if (this->siwemessage().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_siwemessage());
- }
-
- // bytes siweSignature = 4;
- if (this->siwesignature().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_siwesignature());
- }
-
- // string userPublicKey = 5;
- if (this->userpublickey().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userpublickey());
- }
-
- 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 WalletLoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.WalletLoginRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const WalletLoginRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletLoginRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.WalletLoginRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.WalletLoginRequest)
- MergeFrom(*source);
- }
-}
-
-void WalletLoginRequest::MergeFrom(const WalletLoginRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.WalletLoginRequest)
- 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.deviceid().size() > 0) {
- _internal_set_deviceid(from._internal_deviceid());
- }
- if (from.siwemessage().size() > 0) {
- _internal_set_siwemessage(from._internal_siwemessage());
- }
- if (from.siwesignature().size() > 0) {
- _internal_set_siwesignature(from._internal_siwesignature());
- }
- if (from.userpublickey().size() > 0) {
- _internal_set_userpublickey(from._internal_userpublickey());
- }
-}
-
-void WalletLoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.WalletLoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void WalletLoginRequest::CopyFrom(const WalletLoginRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.WalletLoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool WalletLoginRequest::IsInitialized() const {
- return true;
-}
-
-void WalletLoginRequest::InternalSwap(WalletLoginRequest* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- siwemessage_.Swap(&other->siwemessage_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- siwesignature_.Swap(&other->siwesignature_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- userpublickey_.Swap(&other->userpublickey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata WalletLoginRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class WalletLoginResponse::_Internal {
- public:
-};
-
-WalletLoginResponse::WalletLoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.WalletLoginResponse)
-}
-WalletLoginResponse::WalletLoginResponse(const WalletLoginResponse& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_accesstoken().empty()) {
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_accesstoken(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.WalletLoginResponse)
-}
-
-void WalletLoginResponse::SharedCtor() {
-accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-WalletLoginResponse::~WalletLoginResponse() {
- // @@protoc_insertion_point(destructor:identity.WalletLoginResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void WalletLoginResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- accesstoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void WalletLoginResponse::ArenaDtor(void* object) {
- WalletLoginResponse* _this = reinterpret_cast< WalletLoginResponse* >(object);
- (void)_this;
-}
-void WalletLoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void WalletLoginResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void WalletLoginResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.WalletLoginResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- accesstoken_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* WalletLoginResponse::_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 accessToken = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_accesstoken();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.WalletLoginResponse.accessToken"));
- 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* WalletLoginResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.WalletLoginResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // string accessToken = 1;
- if (this->accesstoken().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.WalletLoginResponse.accessToken");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_accesstoken(), 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:identity.WalletLoginResponse)
- return target;
-}
-
-size_t WalletLoginResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.WalletLoginResponse)
- 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 accessToken = 1;
- if (this->accesstoken().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_accesstoken());
- }
-
- 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 WalletLoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.WalletLoginResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const WalletLoginResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<WalletLoginResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.WalletLoginResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.WalletLoginResponse)
- MergeFrom(*source);
- }
-}
-
-void WalletLoginResponse::MergeFrom(const WalletLoginResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.WalletLoginResponse)
- 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.accesstoken().size() > 0) {
- _internal_set_accesstoken(from._internal_accesstoken());
- }
-}
-
-void WalletLoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.WalletLoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void WalletLoginResponse::CopyFrom(const WalletLoginResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.WalletLoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool WalletLoginResponse::IsInitialized() const {
- return true;
-}
-
-void WalletLoginResponse::InternalSwap(WalletLoginResponse* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- accesstoken_.Swap(&other->accesstoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata WalletLoginResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class RegistrationRequest::_Internal {
- public:
- static const ::identity::PakeRegistrationRequestAndUserID& pakeregistrationrequestanduserid(const RegistrationRequest* msg);
- static const ::identity::PakeRegistrationUploadAndCredentialRequest& pakeregistrationuploadandcredentialrequest(const RegistrationRequest* msg);
-};
-
-const ::identity::PakeRegistrationRequestAndUserID&
-RegistrationRequest::_Internal::pakeregistrationrequestanduserid(const RegistrationRequest* msg) {
- return *msg->data_.pakeregistrationrequestanduserid_;
-}
-const ::identity::PakeRegistrationUploadAndCredentialRequest&
-RegistrationRequest::_Internal::pakeregistrationuploadandcredentialrequest(const RegistrationRequest* msg) {
- return *msg->data_.pakeregistrationuploadandcredentialrequest_;
-}
-void RegistrationRequest::set_allocated_pakeregistrationrequestanduserid(::identity::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:identity.RegistrationRequest.pakeRegistrationRequestAndUserID)
-}
-void RegistrationRequest::set_allocated_pakeregistrationuploadandcredentialrequest(::identity::PakeRegistrationUploadAndCredentialRequest* pakeregistrationuploadandcredentialrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (pakeregistrationuploadandcredentialrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeregistrationuploadandcredentialrequest);
- if (message_arena != submessage_arena) {
- pakeregistrationuploadandcredentialrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, pakeregistrationuploadandcredentialrequest, submessage_arena);
- }
- set_has_pakeregistrationuploadandcredentialrequest();
- data_.pakeregistrationuploadandcredentialrequest_ = pakeregistrationuploadandcredentialrequest;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.RegistrationRequest.pakeRegistrationUploadAndCredentialRequest)
-}
-RegistrationRequest::RegistrationRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.RegistrationRequest)
-}
-RegistrationRequest::RegistrationRequest(const RegistrationRequest& 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()->::identity::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
- break;
- }
- case kPakeRegistrationUploadAndCredentialRequest: {
- _internal_mutable_pakeregistrationuploadandcredentialrequest()->::identity::PakeRegistrationUploadAndCredentialRequest::MergeFrom(from._internal_pakeregistrationuploadandcredentialrequest());
- break;
- }
- case kPakeCredentialFinalization: {
- _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.RegistrationRequest)
-}
-
-void RegistrationRequest::SharedCtor() {
-clear_has_data();
-}
-
-RegistrationRequest::~RegistrationRequest() {
- // @@protoc_insertion_point(destructor:identity.RegistrationRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void RegistrationRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void RegistrationRequest::ArenaDtor(void* object) {
- RegistrationRequest* _this = reinterpret_cast< RegistrationRequest* >(object);
- (void)_this;
-}
-void RegistrationRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void RegistrationRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void RegistrationRequest::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.RegistrationRequest)
- switch (data_case()) {
- case kPakeRegistrationRequestAndUserID: {
- if (GetArena() == nullptr) {
- delete data_.pakeregistrationrequestanduserid_;
- }
- break;
- }
- case kPakeRegistrationUploadAndCredentialRequest: {
- if (GetArena() == nullptr) {
- delete data_.pakeregistrationuploadandcredentialrequest_;
- }
- break;
- }
- case kPakeCredentialFinalization: {
- data_.pakecredentialfinalization_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void RegistrationRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.RegistrationRequest)
- ::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* RegistrationRequest::_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) {
- // .identity.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;
- // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- ptr = ctx->ParseMessage(_internal_mutable_pakeregistrationuploadandcredentialrequest(), ptr);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // bytes pakeCredentialFinalization = 3;
- case 3:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
- auto str = _internal_mutable_pakecredentialfinalization();
- 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* RegistrationRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.RegistrationRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
- if (_internal_has_pakeregistrationrequestanduserid()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 1, _Internal::pakeregistrationrequestanduserid(this), target, stream);
- }
-
- // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
- if (_internal_has_pakeregistrationuploadandcredentialrequest()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 2, _Internal::pakeregistrationuploadandcredentialrequest(this), target, stream);
- }
-
- // bytes pakeCredentialFinalization = 3;
- if (_internal_has_pakecredentialfinalization()) {
- target = stream->WriteBytesMaybeAliased(
- 3, this->_internal_pakecredentialfinalization(), 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:identity.RegistrationRequest)
- return target;
-}
-
-size_t RegistrationRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.RegistrationRequest)
- 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()) {
- // .identity.PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
- case kPakeRegistrationRequestAndUserID: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakeregistrationrequestanduserid_);
- break;
- }
- // .identity.PakeRegistrationUploadAndCredentialRequest pakeRegistrationUploadAndCredentialRequest = 2;
- case kPakeRegistrationUploadAndCredentialRequest: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakeregistrationuploadandcredentialrequest_);
- break;
- }
- // bytes pakeCredentialFinalization = 3;
- case kPakeCredentialFinalization: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
- this->_internal_pakecredentialfinalization());
- 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 RegistrationRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.RegistrationRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const RegistrationRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RegistrationRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.RegistrationRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.RegistrationRequest)
- MergeFrom(*source);
- }
-}
-
-void RegistrationRequest::MergeFrom(const RegistrationRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.RegistrationRequest)
- 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()->::identity::PakeRegistrationRequestAndUserID::MergeFrom(from._internal_pakeregistrationrequestanduserid());
- break;
- }
- case kPakeRegistrationUploadAndCredentialRequest: {
- _internal_mutable_pakeregistrationuploadandcredentialrequest()->::identity::PakeRegistrationUploadAndCredentialRequest::MergeFrom(from._internal_pakeregistrationuploadandcredentialrequest());
- break;
- }
- case kPakeCredentialFinalization: {
- _internal_set_pakecredentialfinalization(from._internal_pakecredentialfinalization());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void RegistrationRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.RegistrationRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void RegistrationRequest::CopyFrom(const RegistrationRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.RegistrationRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool RegistrationRequest::IsInitialized() const {
- return true;
-}
-
-void RegistrationRequest::InternalSwap(RegistrationRequest* 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 RegistrationRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class RegistrationResponse::_Internal {
- public:
- static const ::identity::PakeLoginResponse& pakeloginresponse(const RegistrationResponse* msg);
-};
-
-const ::identity::PakeLoginResponse&
-RegistrationResponse::_Internal::pakeloginresponse(const RegistrationResponse* msg) {
- return *msg->data_.pakeloginresponse_;
-}
-void RegistrationResponse::set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (pakeloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginresponse);
- if (message_arena != submessage_arena) {
- pakeloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, pakeloginresponse, submessage_arena);
- }
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = pakeloginresponse;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.RegistrationResponse.pakeLoginResponse)
-}
-RegistrationResponse::RegistrationResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.RegistrationResponse)
-}
-RegistrationResponse::RegistrationResponse(const RegistrationResponse& 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 kPakeLoginResponse: {
- _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.RegistrationResponse)
-}
-
-void RegistrationResponse::SharedCtor() {
-clear_has_data();
-}
-
-RegistrationResponse::~RegistrationResponse() {
- // @@protoc_insertion_point(destructor:identity.RegistrationResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void RegistrationResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void RegistrationResponse::ArenaDtor(void* object) {
- RegistrationResponse* _this = reinterpret_cast< RegistrationResponse* >(object);
- (void)_this;
-}
-void RegistrationResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void RegistrationResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void RegistrationResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.RegistrationResponse)
- switch (data_case()) {
- case kPakeRegistrationResponse: {
- data_.pakeregistrationresponse_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
- break;
- }
- case kPakeLoginResponse: {
- if (GetArena() == nullptr) {
- delete data_.pakeloginresponse_;
- }
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void RegistrationResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.RegistrationResponse)
- ::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* RegistrationResponse::_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;
- // .identity.PakeLoginResponse pakeLoginResponse = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- ptr = ctx->ParseMessage(_internal_mutable_pakeloginresponse(), 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* RegistrationResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.RegistrationResponse)
- ::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);
- }
-
- // .identity.PakeLoginResponse pakeLoginResponse = 2;
- if (_internal_has_pakeloginresponse()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 2, _Internal::pakeloginresponse(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:identity.RegistrationResponse)
- return target;
-}
-
-size_t RegistrationResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.RegistrationResponse)
- 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;
- }
- // .identity.PakeLoginResponse pakeLoginResponse = 2;
- case kPakeLoginResponse: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakeloginresponse_);
- 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 RegistrationResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.RegistrationResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const RegistrationResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RegistrationResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.RegistrationResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.RegistrationResponse)
- MergeFrom(*source);
- }
-}
-
-void RegistrationResponse::MergeFrom(const RegistrationResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.RegistrationResponse)
- 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 kPakeLoginResponse: {
- _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void RegistrationResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.RegistrationResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void RegistrationResponse::CopyFrom(const RegistrationResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.RegistrationResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool RegistrationResponse::IsInitialized() const {
- return true;
-}
-
-void RegistrationResponse::InternalSwap(RegistrationResponse* 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 RegistrationResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class LoginRequest::_Internal {
- public:
- static const ::identity::PakeLoginRequest& pakeloginrequest(const LoginRequest* msg);
- static const ::identity::WalletLoginRequest& walletloginrequest(const LoginRequest* msg);
-};
-
-const ::identity::PakeLoginRequest&
-LoginRequest::_Internal::pakeloginrequest(const LoginRequest* msg) {
- return *msg->data_.pakeloginrequest_;
-}
-const ::identity::WalletLoginRequest&
-LoginRequest::_Internal::walletloginrequest(const LoginRequest* msg) {
- return *msg->data_.walletloginrequest_;
-}
-void LoginRequest::set_allocated_pakeloginrequest(::identity::PakeLoginRequest* pakeloginrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (pakeloginrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginrequest);
- if (message_arena != submessage_arena) {
- pakeloginrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, pakeloginrequest, submessage_arena);
- }
- set_has_pakeloginrequest();
- data_.pakeloginrequest_ = pakeloginrequest;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.LoginRequest.pakeLoginRequest)
-}
-void LoginRequest::set_allocated_walletloginrequest(::identity::WalletLoginRequest* walletloginrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (walletloginrequest) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletloginrequest);
- if (message_arena != submessage_arena) {
- walletloginrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, walletloginrequest, submessage_arena);
- }
- set_has_walletloginrequest();
- data_.walletloginrequest_ = walletloginrequest;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.LoginRequest.walletLoginRequest)
-}
-LoginRequest::LoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.LoginRequest)
-}
-LoginRequest::LoginRequest(const LoginRequest& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- clear_has_data();
- switch (from.data_case()) {
- case kPakeLoginRequest: {
- _internal_mutable_pakeloginrequest()->::identity::PakeLoginRequest::MergeFrom(from._internal_pakeloginrequest());
- break;
- }
- case kWalletLoginRequest: {
- _internal_mutable_walletloginrequest()->::identity::WalletLoginRequest::MergeFrom(from._internal_walletloginrequest());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.LoginRequest)
-}
-
-void LoginRequest::SharedCtor() {
-clear_has_data();
-}
-
-LoginRequest::~LoginRequest() {
- // @@protoc_insertion_point(destructor:identity.LoginRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void LoginRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void LoginRequest::ArenaDtor(void* object) {
- LoginRequest* _this = reinterpret_cast< LoginRequest* >(object);
- (void)_this;
-}
-void LoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void LoginRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void LoginRequest::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.LoginRequest)
- switch (data_case()) {
- case kPakeLoginRequest: {
- if (GetArena() == nullptr) {
- delete data_.pakeloginrequest_;
- }
- break;
- }
- case kWalletLoginRequest: {
- if (GetArena() == nullptr) {
- delete data_.walletloginrequest_;
- }
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void LoginRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.LoginRequest)
- ::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* LoginRequest::_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) {
- // .identity.PakeLoginRequest pakeLoginRequest = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- ptr = ctx->ParseMessage(_internal_mutable_pakeloginrequest(), ptr);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // .identity.WalletLoginRequest walletLoginRequest = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- ptr = ctx->ParseMessage(_internal_mutable_walletloginrequest(), 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* LoginRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.LoginRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // .identity.PakeLoginRequest pakeLoginRequest = 1;
- if (_internal_has_pakeloginrequest()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 1, _Internal::pakeloginrequest(this), target, stream);
- }
-
- // .identity.WalletLoginRequest walletLoginRequest = 2;
- if (_internal_has_walletloginrequest()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 2, _Internal::walletloginrequest(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:identity.LoginRequest)
- return target;
-}
-
-size_t LoginRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.LoginRequest)
- 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()) {
- // .identity.PakeLoginRequest pakeLoginRequest = 1;
- case kPakeLoginRequest: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakeloginrequest_);
- break;
- }
- // .identity.WalletLoginRequest walletLoginRequest = 2;
- case kWalletLoginRequest: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.walletloginrequest_);
- 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 LoginRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.LoginRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const LoginRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LoginRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.LoginRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.LoginRequest)
- MergeFrom(*source);
- }
-}
-
-void LoginRequest::MergeFrom(const LoginRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.LoginRequest)
- 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 kPakeLoginRequest: {
- _internal_mutable_pakeloginrequest()->::identity::PakeLoginRequest::MergeFrom(from._internal_pakeloginrequest());
- break;
- }
- case kWalletLoginRequest: {
- _internal_mutable_walletloginrequest()->::identity::WalletLoginRequest::MergeFrom(from._internal_walletloginrequest());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void LoginRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.LoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void LoginRequest::CopyFrom(const LoginRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.LoginRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool LoginRequest::IsInitialized() const {
- return true;
-}
-
-void LoginRequest::InternalSwap(LoginRequest* 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 LoginRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class LoginResponse::_Internal {
- public:
- static const ::identity::PakeLoginResponse& pakeloginresponse(const LoginResponse* msg);
- static const ::identity::WalletLoginResponse& walletloginresponse(const LoginResponse* msg);
-};
-
-const ::identity::PakeLoginResponse&
-LoginResponse::_Internal::pakeloginresponse(const LoginResponse* msg) {
- return *msg->data_.pakeloginresponse_;
-}
-const ::identity::WalletLoginResponse&
-LoginResponse::_Internal::walletloginresponse(const LoginResponse* msg) {
- return *msg->data_.walletloginresponse_;
-}
-void LoginResponse::set_allocated_pakeloginresponse(::identity::PakeLoginResponse* pakeloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (pakeloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(pakeloginresponse);
- if (message_arena != submessage_arena) {
- pakeloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, pakeloginresponse, submessage_arena);
- }
- set_has_pakeloginresponse();
- data_.pakeloginresponse_ = pakeloginresponse;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.LoginResponse.pakeLoginResponse)
-}
-void LoginResponse::set_allocated_walletloginresponse(::identity::WalletLoginResponse* walletloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
- clear_data();
- if (walletloginresponse) {
- ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
- ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(walletloginresponse);
- if (message_arena != submessage_arena) {
- walletloginresponse = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
- message_arena, walletloginresponse, submessage_arena);
- }
- set_has_walletloginresponse();
- data_.walletloginresponse_ = walletloginresponse;
- }
- // @@protoc_insertion_point(field_set_allocated:identity.LoginResponse.walletLoginResponse)
-}
-LoginResponse::LoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.LoginResponse)
-}
-LoginResponse::LoginResponse(const LoginResponse& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- clear_has_data();
- switch (from.data_case()) {
- case kPakeLoginResponse: {
- _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
- break;
- }
- case kWalletLoginResponse: {
- _internal_mutable_walletloginresponse()->::identity::WalletLoginResponse::MergeFrom(from._internal_walletloginresponse());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- // @@protoc_insertion_point(copy_constructor:identity.LoginResponse)
-}
-
-void LoginResponse::SharedCtor() {
-clear_has_data();
-}
-
-LoginResponse::~LoginResponse() {
- // @@protoc_insertion_point(destructor:identity.LoginResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void LoginResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- if (has_data()) {
- clear_data();
- }
-}
-
-void LoginResponse::ArenaDtor(void* object) {
- LoginResponse* _this = reinterpret_cast< LoginResponse* >(object);
- (void)_this;
-}
-void LoginResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void LoginResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void LoginResponse::clear_data() {
-// @@protoc_insertion_point(one_of_clear_start:identity.LoginResponse)
- switch (data_case()) {
- case kPakeLoginResponse: {
- if (GetArena() == nullptr) {
- delete data_.pakeloginresponse_;
- }
- break;
- }
- case kWalletLoginResponse: {
- if (GetArena() == nullptr) {
- delete data_.walletloginresponse_;
- }
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
- _oneof_case_[0] = DATA_NOT_SET;
-}
-
-
-void LoginResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.LoginResponse)
- ::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* LoginResponse::_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) {
- // .identity.PakeLoginResponse pakeLoginResponse = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- ptr = ctx->ParseMessage(_internal_mutable_pakeloginresponse(), ptr);
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // .identity.WalletLoginResponse walletLoginResponse = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- ptr = ctx->ParseMessage(_internal_mutable_walletloginresponse(), 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* LoginResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.LoginResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // .identity.PakeLoginResponse pakeLoginResponse = 1;
- if (_internal_has_pakeloginresponse()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 1, _Internal::pakeloginresponse(this), target, stream);
- }
-
- // .identity.WalletLoginResponse walletLoginResponse = 2;
- if (_internal_has_walletloginresponse()) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
- InternalWriteMessage(
- 2, _Internal::walletloginresponse(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:identity.LoginResponse)
- return target;
-}
-
-size_t LoginResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.LoginResponse)
- 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()) {
- // .identity.PakeLoginResponse pakeLoginResponse = 1;
- case kPakeLoginResponse: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.pakeloginresponse_);
- break;
- }
- // .identity.WalletLoginResponse walletLoginResponse = 2;
- case kWalletLoginResponse: {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
- *data_.walletloginresponse_);
- 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 LoginResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.LoginResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const LoginResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LoginResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.LoginResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.LoginResponse)
- MergeFrom(*source);
- }
-}
-
-void LoginResponse::MergeFrom(const LoginResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.LoginResponse)
- 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 kPakeLoginResponse: {
- _internal_mutable_pakeloginresponse()->::identity::PakeLoginResponse::MergeFrom(from._internal_pakeloginresponse());
- break;
- }
- case kWalletLoginResponse: {
- _internal_mutable_walletloginresponse()->::identity::WalletLoginResponse::MergeFrom(from._internal_walletloginresponse());
- break;
- }
- case DATA_NOT_SET: {
- break;
- }
- }
-}
-
-void LoginResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.LoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void LoginResponse::CopyFrom(const LoginResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.LoginResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool LoginResponse::IsInitialized() const {
- return true;
-}
-
-void LoginResponse::InternalSwap(LoginResponse* 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 LoginResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class VerifyUserTokenRequest::_Internal {
- public:
-};
-
-VerifyUserTokenRequest::VerifyUserTokenRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.VerifyUserTokenRequest)
-}
-VerifyUserTokenRequest::VerifyUserTokenRequest(const VerifyUserTokenRequest& 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());
- }
- deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_deviceid().empty()) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
- GetArena());
- }
- accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_accesstoken().empty()) {
- accesstoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_accesstoken(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.VerifyUserTokenRequest)
-}
-
-void VerifyUserTokenRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-accesstoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-VerifyUserTokenRequest::~VerifyUserTokenRequest() {
- // @@protoc_insertion_point(destructor:identity.VerifyUserTokenRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void VerifyUserTokenRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- accesstoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void VerifyUserTokenRequest::ArenaDtor(void* object) {
- VerifyUserTokenRequest* _this = reinterpret_cast< VerifyUserTokenRequest* >(object);
- (void)_this;
-}
-void VerifyUserTokenRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void VerifyUserTokenRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void VerifyUserTokenRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.VerifyUserTokenRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- deviceid_.ClearToEmpty();
- accesstoken_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* VerifyUserTokenRequest::_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, "identity.VerifyUserTokenRequest.userID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string deviceID = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_deviceid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.VerifyUserTokenRequest.deviceID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string accessToken = 3;
- case 3:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
- auto str = _internal_mutable_accesstoken();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.VerifyUserTokenRequest.accessToken"));
- 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* VerifyUserTokenRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.VerifyUserTokenRequest)
- ::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,
- "identity.VerifyUserTokenRequest.userID");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.VerifyUserTokenRequest.deviceID");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_deviceid(), target);
- }
-
- // string accessToken = 3;
- if (this->accesstoken().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_accesstoken().data(), static_cast<int>(this->_internal_accesstoken().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.VerifyUserTokenRequest.accessToken");
- target = stream->WriteStringMaybeAliased(
- 3, this->_internal_accesstoken(), 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:identity.VerifyUserTokenRequest)
- return target;
-}
-
-size_t VerifyUserTokenRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.VerifyUserTokenRequest)
- 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 deviceID = 2;
- if (this->deviceid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_deviceid());
- }
-
- // string accessToken = 3;
- if (this->accesstoken().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_accesstoken());
- }
-
- 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 VerifyUserTokenRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.VerifyUserTokenRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const VerifyUserTokenRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VerifyUserTokenRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.VerifyUserTokenRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.VerifyUserTokenRequest)
- MergeFrom(*source);
- }
-}
-
-void VerifyUserTokenRequest::MergeFrom(const VerifyUserTokenRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.VerifyUserTokenRequest)
- 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.deviceid().size() > 0) {
- _internal_set_deviceid(from._internal_deviceid());
- }
- if (from.accesstoken().size() > 0) {
- _internal_set_accesstoken(from._internal_accesstoken());
- }
-}
-
-void VerifyUserTokenRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.VerifyUserTokenRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void VerifyUserTokenRequest::CopyFrom(const VerifyUserTokenRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.VerifyUserTokenRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool VerifyUserTokenRequest::IsInitialized() const {
- return true;
-}
-
-void VerifyUserTokenRequest::InternalSwap(VerifyUserTokenRequest* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- accesstoken_.Swap(&other->accesstoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata VerifyUserTokenRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class VerifyUserTokenResponse::_Internal {
- public:
-};
-
-VerifyUserTokenResponse::VerifyUserTokenResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.VerifyUserTokenResponse)
-}
-VerifyUserTokenResponse::VerifyUserTokenResponse(const VerifyUserTokenResponse& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- tokenvalid_ = from.tokenvalid_;
- // @@protoc_insertion_point(copy_constructor:identity.VerifyUserTokenResponse)
-}
-
-void VerifyUserTokenResponse::SharedCtor() {
-tokenvalid_ = false;
-}
-
-VerifyUserTokenResponse::~VerifyUserTokenResponse() {
- // @@protoc_insertion_point(destructor:identity.VerifyUserTokenResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void VerifyUserTokenResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
-}
-
-void VerifyUserTokenResponse::ArenaDtor(void* object) {
- VerifyUserTokenResponse* _this = reinterpret_cast< VerifyUserTokenResponse* >(object);
- (void)_this;
-}
-void VerifyUserTokenResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void VerifyUserTokenResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void VerifyUserTokenResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.VerifyUserTokenResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- tokenvalid_ = false;
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* VerifyUserTokenResponse::_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 tokenValid = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
- tokenvalid_ = ::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* VerifyUserTokenResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.VerifyUserTokenResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // bool tokenValid = 1;
- if (this->tokenvalid() != 0) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_tokenvalid(), 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:identity.VerifyUserTokenResponse)
- return target;
-}
-
-size_t VerifyUserTokenResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.VerifyUserTokenResponse)
- 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 tokenValid = 1;
- if (this->tokenvalid() != 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 VerifyUserTokenResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.VerifyUserTokenResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const VerifyUserTokenResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VerifyUserTokenResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.VerifyUserTokenResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.VerifyUserTokenResponse)
- MergeFrom(*source);
- }
-}
-
-void VerifyUserTokenResponse::MergeFrom(const VerifyUserTokenResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.VerifyUserTokenResponse)
- 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.tokenvalid() != 0) {
- _internal_set_tokenvalid(from._internal_tokenvalid());
- }
-}
-
-void VerifyUserTokenResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.VerifyUserTokenResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void VerifyUserTokenResponse::CopyFrom(const VerifyUserTokenResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.VerifyUserTokenResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool VerifyUserTokenResponse::IsInitialized() const {
- return true;
-}
-
-void VerifyUserTokenResponse::InternalSwap(VerifyUserTokenResponse* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- swap(tokenvalid_, other->tokenvalid_);
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata VerifyUserTokenResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class GetUserIDRequest::_Internal {
- public:
-};
-
-GetUserIDRequest::GetUserIDRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.GetUserIDRequest)
-}
-GetUserIDRequest::GetUserIDRequest(const GetUserIDRequest& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- userinfo_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_userinfo().empty()) {
- userinfo_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userinfo(),
- GetArena());
- }
- authtype_ = from.authtype_;
- // @@protoc_insertion_point(copy_constructor:identity.GetUserIDRequest)
-}
-
-void GetUserIDRequest::SharedCtor() {
-userinfo_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-authtype_ = 0;
-}
-
-GetUserIDRequest::~GetUserIDRequest() {
- // @@protoc_insertion_point(destructor:identity.GetUserIDRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void GetUserIDRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userinfo_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GetUserIDRequest::ArenaDtor(void* object) {
- GetUserIDRequest* _this = reinterpret_cast< GetUserIDRequest* >(object);
- (void)_this;
-}
-void GetUserIDRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GetUserIDRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void GetUserIDRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.GetUserIDRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userinfo_.ClearToEmpty();
- authtype_ = 0;
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* GetUserIDRequest::_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) {
- // .identity.GetUserIDRequest.AuthType authType = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
- ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
- CHK_(ptr);
- _internal_set_authtype(static_cast<::identity::GetUserIDRequest_AuthType>(val));
- } else goto handle_unusual;
- continue;
- // string userInfo = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_userinfo();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.GetUserIDRequest.userInfo"));
- 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* GetUserIDRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.GetUserIDRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // .identity.GetUserIDRequest.AuthType authType = 1;
- if (this->authtype() != 0) {
- target = stream->EnsureSpace(target);
- target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
- 1, this->_internal_authtype(), target);
- }
-
- // string userInfo = 2;
- if (this->userinfo().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_userinfo().data(), static_cast<int>(this->_internal_userinfo().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.GetUserIDRequest.userInfo");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_userinfo(), 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:identity.GetUserIDRequest)
- return target;
-}
-
-size_t GetUserIDRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.GetUserIDRequest)
- 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 userInfo = 2;
- if (this->userinfo().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_userinfo());
- }
-
- // .identity.GetUserIDRequest.AuthType authType = 1;
- if (this->authtype() != 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_authtype());
- }
-
- 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 GetUserIDRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.GetUserIDRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const GetUserIDRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GetUserIDRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.GetUserIDRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.GetUserIDRequest)
- MergeFrom(*source);
- }
-}
-
-void GetUserIDRequest::MergeFrom(const GetUserIDRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.GetUserIDRequest)
- 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.userinfo().size() > 0) {
- _internal_set_userinfo(from._internal_userinfo());
- }
- if (from.authtype() != 0) {
- _internal_set_authtype(from._internal_authtype());
- }
-}
-
-void GetUserIDRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.GetUserIDRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void GetUserIDRequest::CopyFrom(const GetUserIDRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.GetUserIDRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool GetUserIDRequest::IsInitialized() const {
- return true;
-}
-
-void GetUserIDRequest::InternalSwap(GetUserIDRequest* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userinfo_.Swap(&other->userinfo_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- swap(authtype_, other->authtype_);
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata GetUserIDRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class GetUserIDResponse::_Internal {
- public:
-};
-
-GetUserIDResponse::GetUserIDResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.GetUserIDResponse)
-}
-GetUserIDResponse::GetUserIDResponse(const GetUserIDResponse& 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());
- }
- // @@protoc_insertion_point(copy_constructor:identity.GetUserIDResponse)
-}
-
-void GetUserIDResponse::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-GetUserIDResponse::~GetUserIDResponse() {
- // @@protoc_insertion_point(destructor:identity.GetUserIDResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void GetUserIDResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GetUserIDResponse::ArenaDtor(void* object) {
- GetUserIDResponse* _this = reinterpret_cast< GetUserIDResponse* >(object);
- (void)_this;
-}
-void GetUserIDResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GetUserIDResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void GetUserIDResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.GetUserIDResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* GetUserIDResponse::_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, "identity.GetUserIDResponse.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* GetUserIDResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.GetUserIDResponse)
- ::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,
- "identity.GetUserIDResponse.userID");
- target = stream->WriteStringMaybeAliased(
- 1, 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:identity.GetUserIDResponse)
- return target;
-}
-
-size_t GetUserIDResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.GetUserIDResponse)
- 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());
- }
-
- 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 GetUserIDResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.GetUserIDResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const GetUserIDResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GetUserIDResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.GetUserIDResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.GetUserIDResponse)
- MergeFrom(*source);
- }
-}
-
-void GetUserIDResponse::MergeFrom(const GetUserIDResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.GetUserIDResponse)
- 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());
- }
-}
-
-void GetUserIDResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.GetUserIDResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void GetUserIDResponse::CopyFrom(const GetUserIDResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.GetUserIDResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool GetUserIDResponse::IsInitialized() const {
- return true;
-}
-
-void GetUserIDResponse::InternalSwap(GetUserIDResponse* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata GetUserIDResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class GetUserPublicKeyRequest::_Internal {
- public:
-};
-
-GetUserPublicKeyRequest::GetUserPublicKeyRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.GetUserPublicKeyRequest)
-}
-GetUserPublicKeyRequest::GetUserPublicKeyRequest(const GetUserPublicKeyRequest& 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());
- }
- deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_deviceid().empty()) {
- deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.GetUserPublicKeyRequest)
-}
-
-void GetUserPublicKeyRequest::SharedCtor() {
-userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-GetUserPublicKeyRequest::~GetUserPublicKeyRequest() {
- // @@protoc_insertion_point(destructor:identity.GetUserPublicKeyRequest)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void GetUserPublicKeyRequest::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GetUserPublicKeyRequest::ArenaDtor(void* object) {
- GetUserPublicKeyRequest* _this = reinterpret_cast< GetUserPublicKeyRequest* >(object);
- (void)_this;
-}
-void GetUserPublicKeyRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GetUserPublicKeyRequest::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void GetUserPublicKeyRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.GetUserPublicKeyRequest)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- userid_.ClearToEmpty();
- deviceid_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* GetUserPublicKeyRequest::_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, "identity.GetUserPublicKeyRequest.userID"));
- CHK_(ptr);
- } else goto handle_unusual;
- continue;
- // string deviceID = 2;
- case 2:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
- auto str = _internal_mutable_deviceid();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.GetUserPublicKeyRequest.deviceID"));
- 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* GetUserPublicKeyRequest::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.GetUserPublicKeyRequest)
- ::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,
- "identity.GetUserPublicKeyRequest.userID");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_userid(), target);
- }
-
- // string deviceID = 2;
- if (this->deviceid().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_deviceid().data(), static_cast<int>(this->_internal_deviceid().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.GetUserPublicKeyRequest.deviceID");
- target = stream->WriteStringMaybeAliased(
- 2, this->_internal_deviceid(), 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:identity.GetUserPublicKeyRequest)
- return target;
-}
-
-size_t GetUserPublicKeyRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.GetUserPublicKeyRequest)
- 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 deviceID = 2;
- if (this->deviceid().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_deviceid());
- }
-
- 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 GetUserPublicKeyRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.GetUserPublicKeyRequest)
- GOOGLE_DCHECK_NE(&from, this);
- const GetUserPublicKeyRequest* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GetUserPublicKeyRequest>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.GetUserPublicKeyRequest)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.GetUserPublicKeyRequest)
- MergeFrom(*source);
- }
-}
-
-void GetUserPublicKeyRequest::MergeFrom(const GetUserPublicKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.GetUserPublicKeyRequest)
- 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.deviceid().size() > 0) {
- _internal_set_deviceid(from._internal_deviceid());
- }
-}
-
-void GetUserPublicKeyRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.GetUserPublicKeyRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void GetUserPublicKeyRequest::CopyFrom(const GetUserPublicKeyRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.GetUserPublicKeyRequest)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool GetUserPublicKeyRequest::IsInitialized() const {
- return true;
-}
-
-void GetUserPublicKeyRequest::InternalSwap(GetUserPublicKeyRequest* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
- deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata GetUserPublicKeyRequest::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// ===================================================================
-
-class GetUserPublicKeyResponse::_Internal {
- public:
-};
-
-GetUserPublicKeyResponse::GetUserPublicKeyResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
- : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
- SharedCtor();
- RegisterArenaDtor(arena);
- // @@protoc_insertion_point(arena_constructor:identity.GetUserPublicKeyResponse)
-}
-GetUserPublicKeyResponse::GetUserPublicKeyResponse(const GetUserPublicKeyResponse& from)
- : ::PROTOBUF_NAMESPACE_ID::Message() {
- _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
- publickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
- if (!from._internal_publickey().empty()) {
- publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_publickey(),
- GetArena());
- }
- // @@protoc_insertion_point(copy_constructor:identity.GetUserPublicKeyResponse)
-}
-
-void GetUserPublicKeyResponse::SharedCtor() {
-publickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-GetUserPublicKeyResponse::~GetUserPublicKeyResponse() {
- // @@protoc_insertion_point(destructor:identity.GetUserPublicKeyResponse)
- SharedDtor();
- _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-void GetUserPublicKeyResponse::SharedDtor() {
- GOOGLE_DCHECK(GetArena() == nullptr);
- publickey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-}
-
-void GetUserPublicKeyResponse::ArenaDtor(void* object) {
- GetUserPublicKeyResponse* _this = reinterpret_cast< GetUserPublicKeyResponse* >(object);
- (void)_this;
-}
-void GetUserPublicKeyResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
-}
-void GetUserPublicKeyResponse::SetCachedSize(int size) const {
- _cached_size_.Set(size);
-}
-
-void GetUserPublicKeyResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:identity.GetUserPublicKeyResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- // Prevent compiler warnings about cached_has_bits being unused
- (void) cached_has_bits;
-
- publickey_.ClearToEmpty();
- _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
-}
-
-const char* GetUserPublicKeyResponse::_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 publicKey = 1;
- case 1:
- if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
- auto str = _internal_mutable_publickey();
- ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
- CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "identity.GetUserPublicKeyResponse.publicKey"));
- 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* GetUserPublicKeyResponse::_InternalSerialize(
- ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
- // @@protoc_insertion_point(serialize_to_array_start:identity.GetUserPublicKeyResponse)
- ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
- (void) cached_has_bits;
-
- // string publicKey = 1;
- if (this->publickey().size() > 0) {
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
- this->_internal_publickey().data(), static_cast<int>(this->_internal_publickey().length()),
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
- "identity.GetUserPublicKeyResponse.publicKey");
- target = stream->WriteStringMaybeAliased(
- 1, this->_internal_publickey(), 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:identity.GetUserPublicKeyResponse)
- return target;
-}
-
-size_t GetUserPublicKeyResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:identity.GetUserPublicKeyResponse)
- 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 publicKey = 1;
- if (this->publickey().size() > 0) {
- total_size += 1 +
- ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
- this->_internal_publickey());
- }
-
- 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 GetUserPublicKeyResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:identity.GetUserPublicKeyResponse)
- GOOGLE_DCHECK_NE(&from, this);
- const GetUserPublicKeyResponse* source =
- ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<GetUserPublicKeyResponse>(
- &from);
- if (source == nullptr) {
- // @@protoc_insertion_point(generalized_merge_from_cast_fail:identity.GetUserPublicKeyResponse)
- ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
- } else {
- // @@protoc_insertion_point(generalized_merge_from_cast_success:identity.GetUserPublicKeyResponse)
- MergeFrom(*source);
- }
-}
-
-void GetUserPublicKeyResponse::MergeFrom(const GetUserPublicKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:identity.GetUserPublicKeyResponse)
- 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.publickey().size() > 0) {
- _internal_set_publickey(from._internal_publickey());
- }
-}
-
-void GetUserPublicKeyResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:identity.GetUserPublicKeyResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-void GetUserPublicKeyResponse::CopyFrom(const GetUserPublicKeyResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:identity.GetUserPublicKeyResponse)
- if (&from == this) return;
- Clear();
- MergeFrom(from);
-}
-
-bool GetUserPublicKeyResponse::IsInitialized() const {
- return true;
-}
-
-void GetUserPublicKeyResponse::InternalSwap(GetUserPublicKeyResponse* other) {
- using std::swap;
- _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
- publickey_.Swap(&other->publickey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
-}
-
-::PROTOBUF_NAMESPACE_ID::Metadata GetUserPublicKeyResponse::GetMetadata() const {
- return GetMetadataStatic();
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-} // namespace identity
-PROTOBUF_NAMESPACE_OPEN
-template<> PROTOBUF_NOINLINE ::identity::PakeRegistrationRequestAndUserID* Arena::CreateMaybeMessage< ::identity::PakeRegistrationRequestAndUserID >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::PakeRegistrationRequestAndUserID >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::PakeCredentialRequestAndUserID* Arena::CreateMaybeMessage< ::identity::PakeCredentialRequestAndUserID >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::PakeCredentialRequestAndUserID >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::PakeLoginRequest* Arena::CreateMaybeMessage< ::identity::PakeLoginRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::PakeLoginRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::PakeLoginResponse* Arena::CreateMaybeMessage< ::identity::PakeLoginResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::PakeLoginResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::PakeRegistrationUploadAndCredentialRequest* Arena::CreateMaybeMessage< ::identity::PakeRegistrationUploadAndCredentialRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::PakeRegistrationUploadAndCredentialRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::WalletLoginRequest* Arena::CreateMaybeMessage< ::identity::WalletLoginRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::WalletLoginRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::WalletLoginResponse* Arena::CreateMaybeMessage< ::identity::WalletLoginResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::WalletLoginResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::RegistrationRequest* Arena::CreateMaybeMessage< ::identity::RegistrationRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::RegistrationRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::RegistrationResponse* Arena::CreateMaybeMessage< ::identity::RegistrationResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::RegistrationResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::LoginRequest* Arena::CreateMaybeMessage< ::identity::LoginRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::LoginRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::LoginResponse* Arena::CreateMaybeMessage< ::identity::LoginResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::LoginResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::VerifyUserTokenRequest* Arena::CreateMaybeMessage< ::identity::VerifyUserTokenRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::VerifyUserTokenRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::VerifyUserTokenResponse* Arena::CreateMaybeMessage< ::identity::VerifyUserTokenResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::VerifyUserTokenResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::GetUserIDRequest* Arena::CreateMaybeMessage< ::identity::GetUserIDRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::GetUserIDRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::GetUserIDResponse* Arena::CreateMaybeMessage< ::identity::GetUserIDResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::GetUserIDResponse >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::GetUserPublicKeyRequest* Arena::CreateMaybeMessage< ::identity::GetUserPublicKeyRequest >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::GetUserPublicKeyRequest >(arena);
-}
-template<> PROTOBUF_NOINLINE ::identity::GetUserPublicKeyResponse* Arena::CreateMaybeMessage< ::identity::GetUserPublicKeyResponse >(Arena* arena) {
- return Arena::CreateMessageInternal< ::identity::GetUserPublicKeyResponse >(arena);
-}
-PROTOBUF_NAMESPACE_CLOSE
-
-// @@protoc_insertion_point(global_scope)
-#include <google/protobuf/port_undef.inc>
diff --git a/shared/protos/identity.proto b/shared/protos/identity.proto
deleted file mode 100644
--- a/shared/protos/identity.proto
+++ /dev/null
@@ -1,238 +0,0 @@
-syntax = "proto3";
-
-package identity.keyserver;
-
-service IdentityKeyserverService {
- // Called by user to register with the Identity Service (PAKE only)
- rpc RegisterUser(stream RegistrationRequest) returns (stream
- RegistrationResponse) {}
- // Called by user to create an active session and get an access token
- rpc LoginUser(stream LoginRequest) returns (stream LoginResponse) {}
- // Called by other services to verify a user's token
- rpc VerifyUserToken(VerifyUserTokenRequest) returns (VerifyUserTokenResponse)
- {}
- // Called by users and keyservers to get userID corresponding to a wallet
- // address or username
- rpc GetUserID(GetUserIDRequest) returns (GetUserIDResponse) {}
-
- rpc DeleteUser(DeleteUserRequest) returns (DeleteUserResponse) {}
- // Called by Ashoat's keyserver with a list of user IDs in MySQL and returns:
- // 1. a list of user IDs that are in DynamoDB but not in the supplied list
- // 2. a list of user IDs that are in the supplied list but not in DynamoDB
- rpc CompareUsers(CompareUsersRequest) returns (CompareUsersResponse) {}
- // Called by clients to get a nonce for a Sign-In with Ethereum message
- rpc GenerateNonce(GenerateNonceRequest) returns (GenerateNonceResponse) {}
- // Called by clients to get session initialization info needed to open a new
- // channel of communication with a given user
- rpc GetSessionInitializationInfo(GetSessionInitializationInfoRequest) returns
- (GetSessionInitializationInfoResponse) {}
-
- rpc UpdateUser(stream UpdateUserRequest) returns
- (stream UpdateUserResponse) {}
-}
-
-// Helper types
-
-message PakeRegistrationRequestAndUserID {
- string userID = 1;
- // ed25519 key for the given user's device
- string signingPublicKey = 2;
- // Message sent to initiate PAKE registration (step 1)
- bytes pakeRegistrationRequest = 3;
- string username = 4;
- // Information specific to a user's device needed to open a new channel of
- // communication with this user
- SessionInitializationInfo sessionInitializationInfo = 5;
-}
-
-message PakeCredentialRequestAndUserID {
- string userID = 1;
- // ed25519 key for the given user's device
- string signingPublicKey = 2;
- // Message sent to initiate PAKE login (step 1)
- bytes pakeCredentialRequest = 3;
- // Information specific to a user's device needed to open a new channel of
- // communication with this user
- SessionInitializationInfo sessionInitializationInfo = 4;
-}
-
-message PakeLoginRequest {
- oneof data {
- PakeCredentialRequestAndUserID pakeCredentialRequestAndUserID = 1;
- // Final message in PAKE login (step 3)
- bytes pakeCredentialFinalization = 2;
- }
-}
-
-message PakeLoginResponse {
- oneof data {
- // Answer sent to the user upon reception of the PAKE login attempt,
- // containing a sealed envelope with the user's private key (step 2)
- bytes pakeCredentialResponse = 1;
- string accessToken = 2;
- }
-}
-
-message PakeRegistrationUploadAndCredentialRequest {
- // Final message in PAKE registration, containing sealed cryptographic
- // identifiers (step 3)
- bytes pakeRegistrationUpload = 1;
- // Message sent to initiate PAKE login (Same as in
- // PakeCredentialRequestAndUserID) (step 1)
- bytes pakeCredentialRequest = 2;
-}
-
-message WalletLoginRequest {
- string userID = 1;
- // ed25519 key for the given user's device
- string signingPublicKey = 2;
- string siweMessage = 3;
- string siweSignature = 4;
- // Information specific to a user's device needed to open a new channel of
- // communication with this user
- SessionInitializationInfo sessionInitializationInfo = 5;
-}
-
-message WalletLoginResponse {
- string accessToken = 1;
-}
-
-message SessionInitializationInfo {
- // Initially, the key-value pairs will be as follows:
- // payload -> stringified JSON containing primary and notification public keys
- // signature -> above payload signed with the signing ed25519 key
- // socialProof -> a signed message used for SIWE (optional)
- map<string, string> info = 1;
-}
-
-// RegisterUser
-
-message RegistrationRequest {
- oneof data {
- PakeRegistrationRequestAndUserID pakeRegistrationRequestAndUserID = 1;
- // We combine the last step of PAKE registration with the first step of PAKE
- // login here to reduce the number of messages sent
- PakeRegistrationUploadAndCredentialRequest
- pakeRegistrationUploadAndCredentialRequest = 2;
- // Final message in PAKE login (Same as in PakeLoginRequest) (step 3)
- bytes pakeCredentialFinalization = 3;
- }
-}
-
-message RegistrationResponse {
- oneof data {
- // Answer sent to the user upon reception of the PAKE registration attempt
- // (step 2)
- bytes pakeRegistrationResponse = 1;
- PakeLoginResponse pakeLoginResponse = 2;
- }
-}
-
-// LoginUser
-
-message LoginRequest {
- oneof data {
- PakeLoginRequest pakeLoginRequest = 1;
- WalletLoginRequest walletLoginRequest = 2;
- }
-}
-
-message LoginResponse {
- oneof data {
- PakeLoginResponse pakeLoginResponse = 1;
- WalletLoginResponse walletLoginResponse = 2;
- }
-}
-
-// VerifyUserToken
-
-message VerifyUserTokenRequest {
- string userID = 1;
- // ed25519 key for the given user's device
- string signingPublicKey = 2;
- string accessToken = 3;
-}
-
-message VerifyUserTokenResponse {
- bool tokenValid = 1;
-}
-
-// GetUserID
-
-message GetUserIDRequest {
- enum AuthType {
- PASSWORD = 0;
- WALLET = 1;
- }
- AuthType authType = 1;
- string userInfo = 2;
-}
-
-message GetUserIDResponse {
- string userID = 1;
-}
-
-// DeleteUser
-
-message DeleteUserRequest {
- string userID = 1;
-}
-
-// Need to respond with a message to show success, an
-// empty reponse should work just fine
-message DeleteUserResponse {}
-
-// CompareUsers
-
-message CompareUsersRequest {
- repeated string users = 1;
-}
-
-message CompareUsersResponse {
- repeated string usersMissingFromKeyserver = 1;
- repeated string usersMissingFromIdentity = 2;
-}
-
-// GenerateNonce
-
-message GenerateNonceRequest {
-}
-
-message GenerateNonceResponse{
- string nonce = 1;
-}
-
-// GetSessionInitializationInfo
-
-message GetSessionInitializationInfoRequest {
- string userID = 1;
-}
-
-message GetSessionInitializationInfoResponse {
- // Map is keyed on devices' public ed25519 key used for signing
- map<string, SessionInitializationInfo> devices = 1;
-}
-
-// UpdateUser
-
-// Messages sent from a client to Identity Service
-message UpdateUserRequest {
- oneof data {
- // Only need user information on initial call, subsequent PAKE commands
- // can infer parameters from first Request + userID
- PakeRegistrationRequestAndUserID request = 1;
- // We combine the last step of PAKE registration with the first step of PAKE
- // login here to reduce the number of messages sent
- PakeRegistrationUploadAndCredentialRequest
- pakeRegistrationUploadAndCredentialRequest = 2;
- bytes pakeLoginFinalizationMessage = 4;
- }
-}
-
-// Messages sent from Identity Service to a client
-message UpdateUserResponse {
- oneof data {
- bytes pakeRegistrationResponse = 1;
- PakeLoginResponse pakeLoginResponse = 2;
- }
-}