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, -) -> 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(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, -) -> Result { - // 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, -) -> 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) - }, - ); - - // 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, - client_login: ClientLogin, - tx: mpsc::Sender, -) -> 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, -) -> Result { - 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(message: Option) -> Error { - error!("Received an unexpected message: {:?}", message); - Error::from_status(Status::GenericFailure) -} - -async fn send_to_mpsc(tx: mpsc::Sender, 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> { - ClientLogin::::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, -) -> Result> { - 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::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 { - 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(message: Option) -> Error { - error!("Received an unexpected message: {:?}", message); - Error::from_status(Status::GenericFailure) -} - -async fn send_to_mpsc(tx: &mpsc::Sender, 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> { - ClientLogin::::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, -) -> Result> { - 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)> { - let client_registration_start_result = - ClientRegistration::::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, - password: &str, - tx: &mpsc::Sender, -) -> Result> { - 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, -) -> Result> { - 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, - tx: &mpsc::Sender, -) -> 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, -) -> Result> { - 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, -) -> Result { - 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, -) -> Result> { - 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, -) -> Result, 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::::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, - registration_upload_bytes: &Vec, -) -> Result, 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, - pake_credential_request: &[u8], -) -> Result, 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, - pake_credential_finalization: &Vec, -) -> Result, 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> + Send + 'static, - >, - >; - - #[instrument(skip(self))] - async fn register_user( - &self, - request: Request>, - ) -> Result, 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> + Send + 'static>>; - - #[instrument(skip(self))] - async fn login_user( - &self, - request: Request>, - ) -> Result, 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, - ) -> Result, 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, - ) -> Result, 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, - ) -> Result, 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, - ) -> Result, 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::::from_iter(mysql_users_vec.clone()); - let ddb_users_set = HashSet::::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, - ) -> Result, 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, - ) -> Result, 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>, - ) -> Result, 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> + 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 { - 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 { - 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 { - 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, - pake_credential_finalization: &Vec, - rng: &mut (impl Rng + CryptoRng), - pake_workflow: PakeWorkflow, - session_initialization_info: &HashMap, -) -> Result { - 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, -) -> Result { - 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, - server_registration: ServerRegistration, - username: &str, - signing_public_key: &str, - session_initialization_info: &HashMap, -) -> 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, -} - -struct LoginResponseAndPakeState { - response: PakeLoginResponseStruct, - pake_state: ServerLogin, -} - -async fn send_to_client( - tx: &tokio::sync::mpsc::Sender>, - response: Result, -) -> 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, - session_initialization_info: HashMap, -} -pub async fn handle_login_request( - message: Option>, - tx: mpsc::Sender>, - client: &DatabaseClient, -) -> Result, 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>, - tx: mpsc::Sender>, - 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>, - session_initialization_info: HashMap, -} - -pub async fn handle_registration_request( - message: Option>, - client: &DatabaseClient, - tx: mpsc::Sender>, -) -> Result { - 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>, - tx: mpsc::Sender>, - client: &DatabaseClient, - registration_state: &RegistrationState, - pake_state: ServerRegistration, -) -> Result, 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>, - tx: mpsc::Sender>, - client: &DatabaseClient, - registration_state: &RegistrationState, - server_login: ServerLogin, -) -> 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, - client: DatabaseClient, - tx: tokio::sync::mpsc::Sender>, -) { - 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, - client: &DatabaseClient, - tx: &tokio::sync::mpsc::Sender>, -) -> Result { - 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>, - client: &DatabaseClient, - tx: &mpsc::Sender>, -) -> Result< - (PakeRegistrationRequestAndUserId, ServerRegistration), - 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 { - 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, 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 { - 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>, - client: &DatabaseClient, - request_and_user_info: &PakeRegistrationRequestAndUserId, - pake_state: ServerRegistration, -) -> Result, 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, - server_registration: ServerRegistration, -) -> 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< - 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, - tx: &mpsc::Sender>, - client: &DatabaseClient, - request_and_user_info: &PakeRegistrationRequestAndUserId, - server_login: ServerLogin, -) -> 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, - pake_credential_finalization: &Vec, -) -> Result { - 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -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) = 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) = 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) = 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) 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) 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) 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 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 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 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 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 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 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 > > > > AsyncService; - template - 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 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 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 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 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 > > > > CallbackService; - typedef CallbackService ExperimentalCallbackService; - template - 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 > > StreamedUnaryService; - typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_VerifyUserToken > > 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -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 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 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 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 -#include - -#include -#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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) -#include -#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 -inline const std::string& GetUserIDRequest_AuthType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::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_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( - &_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(nullptr); - } - - PakeRegistrationRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - PakeCredentialRequestAndUserID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - PakeLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - PakeLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - PakeRegistrationUploadAndCredentialRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - WalletLoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - WalletLoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - RegistrationRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - RegistrationResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - LoginRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - LoginResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - VerifyUserTokenRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - VerifyUserTokenResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - GetUserIDRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 - static inline const std::string& AuthType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::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 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( - &_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(nullptr); - } - - GetUserIDResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - GetUserPublicKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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( - &_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(nullptr); - } - - GetUserPublicKeyResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const 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 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 -#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 - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -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(&::identity::_PakeRegistrationRequestAndUserID_default_instance_), - reinterpret_cast(&::identity::_PakeCredentialRequestAndUserID_default_instance_), - reinterpret_cast(&::identity::_PakeLoginRequest_default_instance_), - reinterpret_cast(&::identity::_PakeLoginResponse_default_instance_), - reinterpret_cast(&::identity::_PakeRegistrationUploadAndCredentialRequest_default_instance_), - reinterpret_cast(&::identity::_WalletLoginRequest_default_instance_), - reinterpret_cast(&::identity::_WalletLoginResponse_default_instance_), - reinterpret_cast(&::identity::_RegistrationRequest_default_instance_), - reinterpret_cast(&::identity::_RegistrationResponse_default_instance_), - reinterpret_cast(&::identity::_LoginRequest_default_instance_), - reinterpret_cast(&::identity::_LoginResponse_default_instance_), - reinterpret_cast(&::identity::_VerifyUserTokenRequest_default_instance_), - reinterpret_cast(&::identity::_VerifyUserTokenResponse_default_instance_), - reinterpret_cast(&::identity::_GetUserIDRequest_default_instance_), - reinterpret_cast(&::identity::_GetUserIDResponse_default_instance_), - reinterpret_cast(&::identity::_GetUserPublicKeyRequest_default_instance_), - reinterpret_cast(&::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(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(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(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(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( - &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(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(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(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( - &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( - &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(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( - &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( - &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(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(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(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(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( - &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(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( - &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( - &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( - &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( - &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( - &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(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(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(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( - &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( - &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(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( - &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(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( - &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(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(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( - &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(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( - &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 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 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 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; - } -}