diff --git a/services/identity/src/service.rs b/services/identity/src/service.rs index 0defea3f6..29d257fca 100644 --- a/services/identity/src/service.rs +++ b/services/identity/src/service.rs @@ -1,718 +1,726 @@ use aws_sdk_dynamodb::Error as DynamoDBError; use chrono::Utc; use constant_time_eq::constant_time_eq; use futures_core::Stream; use opaque_ke::{ CredentialFinalization, CredentialRequest, RegistrationRequest as PakeRegistrationRequest, ServerLogin, ServerLoginStartParameters, }; use opaque_ke::{RegistrationUpload, ServerRegistration}; use rand::rngs::OsRng; use rand::{CryptoRng, Rng}; use siwe::Message; 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; use crate::opaque::Cipher; use crate::token::{AccessTokenData, AuthType}; use crate::{config::Config, database::Error as DBError}; pub use proto::identity_service_server::IdentityServiceServer; use proto::{ get_user_id_request::AuthType as ProtoAuthType, identity_service_server::IdentityService, 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, GetUserIdRequest, - GetUserIdResponse, LoginRequest, LoginResponse, - PakeLoginRequest as PakeLoginRequestStruct, + GetUserIdResponse, GetUserPublicKeyRequest, GetUserPublicKeyResponse, + LoginRequest, LoginResponse, PakeLoginRequest as PakeLoginRequestStruct, PakeLoginResponse as PakeLoginResponseStruct, RegistrationRequest, RegistrationResponse, VerifyUserTokenRequest, VerifyUserTokenResponse, WalletLoginRequest as WalletLoginRequestStruct, WalletLoginResponse as WalletLoginResponseStruct, }; mod proto { tonic::include_proto!("identity"); } #[derive(Debug)] enum PakeWorkflow { Registration, Login, } #[derive(derive_more::Constructor)] pub struct MyIdentityService { config: Config, client: DatabaseClient, } #[tonic::async_trait] impl IdentityService 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 config = self.config.clone(); let client = self.client.clone(); tokio::spawn(async move { let mut user_id: String = String::new(); let mut device_id: String = String::new(); let mut server_registration: Option> = None; let mut server_login: Option> = None; let mut username: String = String::new(); let mut user_public_key: String = String::new(); let mut num_messages_received = 0; while let Some(message) = in_stream.next().await { match message { Ok(RegistrationRequest { data: Some(PakeRegistrationRequestAndUserId( pake_registration_request_and_user_id, )), }) => { let registration_start_result = pake_registration_start( config.clone(), &mut OsRng, &pake_registration_request_and_user_id.pake_registration_request, num_messages_received, ) .await .map(|registration_response_and_server_registration| { server_registration = Some(registration_response_and_server_registration.1); registration_response_and_server_registration.0 }); if let Err(e) = tx.send(registration_start_result).await { error!("Response was dropped: {}", e); break; } user_id = pake_registration_request_and_user_id.user_id; device_id = pake_registration_request_and_user_id.device_id; username = pake_registration_request_and_user_id.username; user_public_key = pake_registration_request_and_user_id.user_public_key; } Ok(RegistrationRequest { data: Some(PakeRegistrationUploadAndCredentialRequest( pake_registration_upload_and_credential_request, )), }) => { let registration_finish_and_login_start_result = match pake_registration_finish( &user_id, &device_id, client.clone(), &pake_registration_upload_and_credential_request .pake_registration_upload, server_registration, &username, &user_public_key, num_messages_received, ) .await { Ok(_) => pake_login_start( config.clone(), client.clone(), &user_id.clone(), &pake_registration_upload_and_credential_request .pake_credential_request, num_messages_received, PakeWorkflow::Registration, ) .await .map(|pake_login_response_and_server_login| { server_login = Some(pake_login_response_and_server_login.1); RegistrationResponse { data: Some(PakeRegistrationLoginResponse( pake_login_response_and_server_login.0, )), } }), Err(e) => Err(e), }; if let Err(e) = tx.send(registration_finish_and_login_start_result).await { error!("Response was dropped: {}", e); break; } server_registration = None; } Ok(RegistrationRequest { data: Some(PakeRegistrationCredentialFinalization( pake_credential_finalization, )), }) => { let login_finish_result = pake_login_finish( &user_id, &device_id, &user_public_key, client, server_login, &pake_credential_finalization, &mut OsRng, num_messages_received, PakeWorkflow::Registration, ) .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); } break; } unexpected => { error!("Received an unexpected Result: {:?}", unexpected); if let Err(e) = tx.send(Err(Status::unknown("unknown error"))).await { error!("Response was dropped: {}", e); } break; } } num_messages_received += 1; } }); 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 config = self.config.clone(); let client = self.client.clone(); tokio::spawn(async move { let mut user_id: String = String::new(); let mut device_id: String = String::new(); let mut server_login: Option> = None; let mut user_public_key: String = String::new(); let mut num_messages_received = 0; while let Some(message) = in_stream.next().await { match message { Ok(LoginRequest { data: Some(WalletLoginRequest(req)), }) => { let wallet_login_result = wallet_login_helper( client, req, &mut OsRng, num_messages_received, ) .await; if let Err(e) = tx.send(wallet_login_result).await { error!("Response was dropped: {}", e); } break; } Ok(LoginRequest { data: Some(PakeLoginRequest(PakeLoginRequestStruct { data: Some(PakeCredentialRequestAndUserId( pake_credential_request_and_user_id, )), })), }) => { let login_start_result = pake_login_start( config.clone(), client.clone(), &pake_credential_request_and_user_id.user_id, &pake_credential_request_and_user_id.pake_credential_request, num_messages_received, PakeWorkflow::Login, ) .await .map(|pake_login_response_and_server_login| { server_login = Some(pake_login_response_and_server_login.1); LoginResponse { data: Some(PakeLoginResponse( pake_login_response_and_server_login.0, )), } }); if let Err(e) = tx.send(login_start_result).await { error!("Response was dropped: {}", e); break; } user_id = pake_credential_request_and_user_id.user_id; device_id = pake_credential_request_and_user_id.device_id; user_public_key = pake_credential_request_and_user_id.user_public_key; } Ok(LoginRequest { data: Some(PakeLoginRequest(PakeLoginRequestStruct { data: Some(PakeCredentialFinalization(pake_credential_finalization)), })), }) => { let login_finish_result = pake_login_finish( &user_id, &device_id, &user_public_key, client, server_login, &pake_credential_finalization, &mut OsRng, num_messages_received, PakeWorkflow::Login, ) .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); } break; } unexpected => { error!("Received an unexpected Result: {:?}", unexpected); if let Err(e) = tx.send(Err(Status::unknown("unknown error"))).await { error!("Response was dropped: {}", e); } break; } } num_messages_received += 1; } }); 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.device_id) .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 get_user_public_key( + &self, + request: Request, + ) -> Result, Status> { + unimplemented!() + } } async fn put_token_helper( client: DatabaseClient, auth_type: AuthType, user_id: &str, device_id: &str, rng: &mut (impl Rng + CryptoRng), ) -> Result { if user_id.is_empty() || device_id.is_empty() { error!( "Incomplete data: user ID \"{}\", device ID \"{}\"", user_id, device_id ); return Err(Status::aborted("user not found")); } let access_token_data = AccessTokenData::new( user_id.to_string(), device_id.to_string(), auth_type.clone(), 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, device_id: &str, siwe_message: &str, siwe_signature: Vec, ) -> Result<(), Status> { if user_id.is_empty() || device_id.is_empty() { error!( "Incomplete data: user ID {}, device ID {}", user_id, device_id ); 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")); } }; match siwe_message.verify( match siwe_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 {} on device {}: {}", user_id, device_id, 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), num_messages_received: u8, ) -> Result { if num_messages_received != 0 { error!("Too many messages received in stream, aborting"); return Err(Status::aborted("please retry")); } parse_and_verify_siwe_message( &wallet_login_request.user_id, &wallet_login_request.device_id, &wallet_login_request.siwe_message, wallet_login_request.siwe_signature, )?; client .update_users_table( wallet_login_request.user_id.clone(), wallet_login_request.device_id.clone(), None, None, Some(wallet_login_request.user_public_key), ) .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.device_id, rng, ) .await?, })), }) } async fn pake_login_start( config: Config, client: DatabaseClient, user_id: &str, pake_credential_request: &[u8], num_messages_received: u8, pake_workflow: PakeWorkflow, ) -> Result<(PakeLoginResponseStruct, ServerLogin), Status> { if (num_messages_received != 0 && matches!(pake_workflow, PakeWorkflow::Login)) || (num_messages_received != 1 && matches!(pake_workflow, PakeWorkflow::Registration)) { error!("Too many messages received in stream, aborting"); return Err(Status::aborted("please retry")); } 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 credential_request = CredentialRequest::deserialize(pake_credential_request).map_err(|e| { error!("Failed to deserialize credential request: {}", e); Status::invalid_argument("invalid message") })?; match ServerLogin::start( &mut OsRng, server_registration, config.server_keypair.private(), credential_request, ServerLoginStartParameters::default(), ) { Ok(server_login_start_result) => Ok(( PakeLoginResponseStruct { data: Some(PakeCredentialResponse( server_login_start_result.message.serialize().map_err(|e| { error!("Failed to serialize PAKE message: {}", e); Status::failed_precondition("internal error") })?, )), }, server_login_start_result.state, )), Err(e) => { error!( "Encountered a PAKE protocol error when starting login: {}", e ); Err(Status::aborted("server error")) } } } async fn pake_login_finish( user_id: &str, device_id: &str, user_public_key: &str, client: DatabaseClient, server_login: Option>, pake_credential_finalization: &[u8], rng: &mut (impl Rng + CryptoRng), num_messages_received: u8, pake_workflow: PakeWorkflow, ) -> Result { if (num_messages_received != 1 && matches!(pake_workflow, PakeWorkflow::Login)) || (num_messages_received != 2 && matches!(pake_workflow, PakeWorkflow::Registration)) { error!("Too many messages received in stream, aborting"); return Err(Status::aborted("please retry")); } if user_id.is_empty() || device_id.is_empty() { error!( "Incomplete data: user ID {}, device ID {}", user_id, device_id ); return Err(Status::aborted("user not found")); } server_login .ok_or_else(|| { error!("Server login missing in {:?} PAKE workflow", pake_workflow); Status::aborted("login failed") })? .finish( CredentialFinalization::deserialize(pake_credential_finalization) .map_err(|e| { error!("Failed to deserialize credential finalization bytes: {}", e); Status::aborted("login failed") })?, ) .map_err(|e| { error!( "Encountered a PAKE protocol error when finishing login: {}", e ); Status::aborted("server error") })?; if matches!(pake_workflow, PakeWorkflow::Login) { client .update_users_table( user_id.to_string(), device_id.to_string(), None, None, Some(user_public_key.to_string()), ) .await .map_err(handle_db_error)?; } Ok(PakeLoginResponseStruct { data: Some(AccessToken( put_token_helper(client, AuthType::Password, user_id, device_id, rng) .await?, )), }) } async fn pake_registration_start( config: Config, rng: &mut (impl Rng + CryptoRng), registration_request_bytes: &[u8], num_messages_received: u8, ) -> Result<(RegistrationResponse, ServerRegistration), Status> { if num_messages_received != 0 { error!("Too many messages received in stream, aborting"); return Err(Status::aborted("please retry")); } match ServerRegistration::::start( rng, PakeRegistrationRequest::deserialize(registration_request_bytes).unwrap(), config.server_keypair.public(), ) { Ok(server_registration_start_result) => Ok(( RegistrationResponse { data: Some(PakeRegistrationResponse( server_registration_start_result.message.serialize(), )), }, server_registration_start_result.state, )), Err(e) => { error!( "Encountered a PAKE protocol error when starting registration: {}", e ); Err(Status::aborted("server error")) } } } async fn pake_registration_finish( user_id: &str, device_id: &str, client: DatabaseClient, registration_upload_bytes: &[u8], server_registration: Option>, username: &str, user_public_key: &str, num_messages_received: u8, ) -> Result<(), Status> { if num_messages_received != 1 { error!("Too many messages received in stream, aborting"); return Err(Status::aborted("please retry")); } if user_id.is_empty() { error!("Incomplete data: user ID not provided"); return Err(Status::aborted("user not found")); } let server_registration_finish_result = server_registration .ok_or_else(|| Status::aborted("registration failed"))? .finish( RegistrationUpload::deserialize(registration_upload_bytes).map_err( |e| { error!("Failed to deserialize registration upload bytes: {}", e); Status::aborted("registration failed") }, )?, ) .map_err(|e| { error!( "Encountered a PAKE protocol error when finishing registration: {}", e ); Status::aborted("server error") })?; match client .update_users_table( user_id.to_string(), device_id.to_string(), Some(server_registration_finish_result), Some(username.to_string()), Some(user_public_key.to_string()), ) .await { Ok(_) => Ok(()), Err(e) => Err(handle_db_error(e)), } } 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") } } } diff --git a/shared/protos/_generated/identity.grpc.pb.cc b/shared/protos/_generated/identity.grpc.pb.cc index 2ead9b7d6..2cd726894 100644 --- a/shared/protos/_generated/identity.grpc.pb.cc +++ b/shared/protos/_generated/identity.grpc.pb.cc @@ -1,196 +1,238 @@ // @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.grpc.pb.h b/shared/protos/_generated/identity.grpc.pb.h index 459ab1c92..676145bad 100644 --- a/shared/protos/_generated/identity.grpc.pb.h +++ b/shared/protos/_generated/identity.grpc.pb.h @@ -1,674 +1,837 @@ // @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); } }; - typedef WithAsyncMethod_RegisterUser > > > AsyncService; + 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; } }; - typedef WithCallbackMethod_RegisterUser > > > CallbackService; + 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; }; - typedef WithStreamedUnaryMethod_VerifyUserToken > StreamedUnaryService; + 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; + typedef WithStreamedUnaryMethod_VerifyUserToken > > StreamedService; }; } // namespace identity #endif // GRPC_identity_2eproto__INCLUDED diff --git a/shared/protos/_generated/identity.pb.cc b/shared/protos/_generated/identity.pb.cc index 951ba523e..8119aa351 100644 --- a/shared/protos/_generated/identity.pb.cc +++ b/shared/protos/_generated/identity.pb.cc @@ -1,4638 +1,5129 @@ // @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[15]; +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(\t2\314\002\n\017IdentityServi" - "ce\022S\n\014RegisterUser\022\035.identity.Registrati" - "onRequest\032\036.identity.RegistrationRespons" - "e\"\000(\0010\001\022B\n\tLoginUser\022\026.identity.LoginReq" - "uest\032\027.identity.LoginResponse\"\000(\0010\001\022X\n\017V" - "erifyUserToken\022 .identity.VerifyUserToke" - "nRequest\032!.identity.VerifyUserTokenRespo" - "nse\"\000\022F\n\tGetUserID\022\032.identity.GetUserIDR" - "equest\032\033.identity.GetUserIDResponse\"\000b\006p" - "roto3" + "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, 2125, descriptor_table_protodef_identity_2eproto, "identity.proto", - &descriptor_table_identity_2eproto_once, nullptr, 0, 15, + 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/_generated/identity.pb.h b/shared/protos/_generated/identity.pb.h index 2834610e4..545f46c4d 100644 --- a/shared/protos/_generated/identity.pb.h +++ b/shared/protos/_generated/identity.pb.h @@ -1,5559 +1,6068 @@ // @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[15] + 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/tunnelbroker.grpc.pb.h b/shared/protos/_generated/tunnelbroker.grpc.pb.h index de82cf33e..b1e17bfc2 100644 --- a/shared/protos/_generated/tunnelbroker.grpc.pb.h +++ b/shared/protos/_generated/tunnelbroker.grpc.pb.h @@ -1,1333 +1,1339 @@ // @generated by the gRPC C++ plugin. // If you make any local change, they will be lost. // source: tunnelbroker.proto #ifndef GRPC_tunnelbroker_2eproto__INCLUDED #define GRPC_tunnelbroker_2eproto__INCLUDED #include "tunnelbroker.pb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace tunnelbroker { class TunnelbrokerService final { public: static constexpr char const* service_full_name() { return "tunnelbroker.TunnelbrokerService"; } class StubInterface { public: virtual ~StubInterface() {} // The old API service methods // to support the native client build // until we switch to the new one // virtual ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>> AsyncCheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>>(AsyncCheckIfPrimaryDeviceOnlineRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>> PrepareAsyncCheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>>(PrepareAsyncCheckIfPrimaryDeviceOnlineRaw(context, request, cq)); } virtual ::grpc::Status BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::tunnelbroker::NewPrimaryResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>> AsyncBecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>>(AsyncBecomeNewPrimaryDeviceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>> PrepareAsyncBecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>>(PrepareAsyncBecomeNewPrimaryDeviceRaw(context, request, cq)); } virtual ::grpc::Status SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::google::protobuf::Empty* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendPongRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendPongRaw(context, request, cq)); } // New API service methods // virtual ::grpc::Status SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::tunnelbroker::SessionSignatureResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>> AsyncSessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>>(AsyncSessionSignatureRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>> PrepareAsyncSessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>>(PrepareAsyncSessionSignatureRaw(context, request, cq)); } virtual ::grpc::Status NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::tunnelbroker::NewSessionResponse* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>> AsyncNewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>>(AsyncNewSessionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>> PrepareAsyncNewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>>(PrepareAsyncNewSessionRaw(context, request, cq)); } virtual ::grpc::Status Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::google::protobuf::Empty* response) = 0; std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> AsyncSend(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(AsyncSendRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>> PrepareAsyncSend(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>>(PrepareAsyncSendRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>> Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) { return std::unique_ptr< ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>>(GetRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>> AsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(AsyncGetRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq)); } // Replacing Send and Get with a single bidirectional streaming RPC + // The client should provide the valid `sessionID` identifier + // from the `NewSession` in the stream request metadata std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> MessagesStream(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(MessagesStreamRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> AsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(AsyncMessagesStreamRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> PrepareAsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(PrepareAsyncMessagesStreamRaw(context, cq)); } class async_interface { public: virtual ~async_interface() {} // The old API service methods // to support the native client build // until we switch to the new one // virtual void CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response, std::function) = 0; virtual void CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response, std::function) = 0; virtual void BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response, std::function) = 0; virtual void SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; // New API service methods // virtual void SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response, std::function) = 0; virtual void SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response, std::function) = 0; virtual void NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function) = 0; virtual void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) = 0; virtual void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) = 0; // Replacing Send and Get with a single bidirectional streaming RPC + // The client should provide the valid `sessionID` identifier + // from the `NewSession` in the stream request metadata virtual void MessagesStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>* 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::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>* AsyncCheckIfPrimaryDeviceOnlineRaw(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::CheckResponse>* PrepareAsyncCheckIfPrimaryDeviceOnlineRaw(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>* AsyncBecomeNewPrimaryDeviceRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewPrimaryResponse>* PrepareAsyncBecomeNewPrimaryDeviceRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendPongRaw(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendPongRaw(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>* AsyncSessionSignatureRaw(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::SessionSignatureResponse>* PrepareAsyncSessionSignatureRaw(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>* AsyncNewSessionRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::tunnelbroker::NewSessionResponse>* PrepareAsyncNewSessionRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* AsyncSendRaw(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::google::protobuf::Empty>* PrepareAsyncSendRaw(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderInterface< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderInterface< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStreamRaw(::grpc::ClientContext* context) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* AsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; virtual ::grpc::ClientAsyncReaderWriterInterface< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* PrepareAsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::tunnelbroker::CheckResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>> AsyncCheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>>(AsyncCheckIfPrimaryDeviceOnlineRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>> PrepareAsyncCheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>>(PrepareAsyncCheckIfPrimaryDeviceOnlineRaw(context, request, cq)); } ::grpc::Status BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::tunnelbroker::NewPrimaryResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>> AsyncBecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>>(AsyncBecomeNewPrimaryDeviceRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>> PrepareAsyncBecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>>(PrepareAsyncBecomeNewPrimaryDeviceRaw(context, request, cq)); } ::grpc::Status SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::google::protobuf::Empty* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendPongRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendPongRaw(context, request, cq)); } ::grpc::Status SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::tunnelbroker::SessionSignatureResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>> AsyncSessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>>(AsyncSessionSignatureRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>> PrepareAsyncSessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>>(PrepareAsyncSessionSignatureRaw(context, request, cq)); } ::grpc::Status NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::tunnelbroker::NewSessionResponse* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>> AsyncNewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>>(AsyncNewSessionRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>> PrepareAsyncNewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>>(PrepareAsyncNewSessionRaw(context, request, cq)); } ::grpc::Status Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::google::protobuf::Empty* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> AsyncSend(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(AsyncSendRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>> PrepareAsyncSend(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>>(PrepareAsyncSendRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReader< ::tunnelbroker::GetResponse>> Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) { return std::unique_ptr< ::grpc::ClientReader< ::tunnelbroker::GetResponse>>(GetRaw(context, request)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> AsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(AsyncGetRaw(context, request, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>> PrepareAsyncGet(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>>(PrepareAsyncGetRaw(context, request, cq)); } std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> MessagesStream(::grpc::ClientContext* context) { return std::unique_ptr< ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(MessagesStreamRaw(context)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> AsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(AsyncMessagesStreamRaw(context, cq, tag)); } std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>> PrepareAsyncMessagesStream(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>>(PrepareAsyncMessagesStreamRaw(context, cq)); } class async final : public StubInterface::async_interface { public: void CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response, std::function) override; void CheckIfPrimaryDeviceOnline(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response, std::function) override; void BecomeNewPrimaryDevice(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response, std::function) override; void SendPong(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; void SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response, std::function) override; void SessionSignature(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response, std::function) override; void NewSession(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response, ::grpc::ClientUnaryReactor* reactor) override; void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, std::function) override; void Send(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response, ::grpc::ClientUnaryReactor* reactor) override; void Get(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ClientReadReactor< ::tunnelbroker::GetResponse>* reactor) override; void MessagesStream(::grpc::ClientContext* context, ::grpc::ClientBidiReactor< ::tunnelbroker::MessageToTunnelbroker,::tunnelbroker::MessageToClient>* 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::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>* AsyncCheckIfPrimaryDeviceOnlineRaw(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::CheckResponse>* PrepareAsyncCheckIfPrimaryDeviceOnlineRaw(::grpc::ClientContext* context, const ::tunnelbroker::CheckRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>* AsyncBecomeNewPrimaryDeviceRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewPrimaryResponse>* PrepareAsyncBecomeNewPrimaryDeviceRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewPrimaryRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendPongRaw(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendPongRaw(::grpc::ClientContext* context, const ::tunnelbroker::PongRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>* AsyncSessionSignatureRaw(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::SessionSignatureResponse>* PrepareAsyncSessionSignatureRaw(::grpc::ClientContext* context, const ::tunnelbroker::SessionSignatureRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>* AsyncNewSessionRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::tunnelbroker::NewSessionResponse>* PrepareAsyncNewSessionRaw(::grpc::ClientContext* context, const ::tunnelbroker::NewSessionRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* AsyncSendRaw(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::google::protobuf::Empty>* PrepareAsyncSendRaw(::grpc::ClientContext* context, const ::tunnelbroker::SendRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReader< ::tunnelbroker::GetResponse>* GetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request) override; ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* AsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReader< ::tunnelbroker::GetResponse>* PrepareAsyncGetRaw(::grpc::ClientContext* context, const ::tunnelbroker::GetRequest& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStreamRaw(::grpc::ClientContext* context) override; ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* AsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; ::grpc::ClientAsyncReaderWriter< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* PrepareAsyncMessagesStreamRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_CheckIfPrimaryDeviceOnline_; const ::grpc::internal::RpcMethod rpcmethod_BecomeNewPrimaryDevice_; const ::grpc::internal::RpcMethod rpcmethod_SendPong_; const ::grpc::internal::RpcMethod rpcmethod_SessionSignature_; const ::grpc::internal::RpcMethod rpcmethod_NewSession_; const ::grpc::internal::RpcMethod rpcmethod_Send_; const ::grpc::internal::RpcMethod rpcmethod_Get_; const ::grpc::internal::RpcMethod rpcmethod_MessagesStream_; }; 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(); // The old API service methods // to support the native client build // until we switch to the new one // virtual ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response); virtual ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response); virtual ::grpc::Status SendPong(::grpc::ServerContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response); // New API service methods // virtual ::grpc::Status SessionSignature(::grpc::ServerContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response); virtual ::grpc::Status NewSession(::grpc::ServerContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response); virtual ::grpc::Status Send(::grpc::ServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response); virtual ::grpc::Status Get(::grpc::ServerContext* context, const ::tunnelbroker::GetRequest* request, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* writer); // Replacing Send and Get with a single bidirectional streaming RPC + // The client should provide the valid `sessionID` identifier + // from the `NewSession` in the stream request metadata virtual ::grpc::Status MessagesStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* stream); }; template class WithAsyncMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodAsync(0); } ~WithAsyncMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCheckIfPrimaryDeviceOnline(::grpc::ServerContext* context, ::tunnelbroker::CheckRequest* request, ::grpc::ServerAsyncResponseWriter< ::tunnelbroker::CheckResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodAsync(1); } ~WithAsyncMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBecomeNewPrimaryDevice(::grpc::ServerContext* context, ::tunnelbroker::NewPrimaryRequest* request, ::grpc::ServerAsyncResponseWriter< ::tunnelbroker::NewPrimaryResponse>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SendPong() { ::grpc::Service::MarkMethodAsync(2); } ~WithAsyncMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendPong(::grpc::ServerContext* context, ::tunnelbroker::PongRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* 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_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_SessionSignature() { ::grpc::Service::MarkMethodAsync(3); } ~WithAsyncMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSessionSignature(::grpc::ServerContext* context, ::tunnelbroker::SessionSignatureRequest* request, ::grpc::ServerAsyncResponseWriter< ::tunnelbroker::SessionSignatureResponse>* 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_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_NewSession() { ::grpc::Service::MarkMethodAsync(4); } ~WithAsyncMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNewSession(::grpc::ServerContext* context, ::tunnelbroker::NewSessionRequest* request, ::grpc::ServerAsyncResponseWriter< ::tunnelbroker::NewSessionResponse>* 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 WithAsyncMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Send() { ::grpc::Service::MarkMethodAsync(5); } ~WithAsyncMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSend(::grpc::ServerContext* context, ::tunnelbroker::SendRequest* request, ::grpc::ServerAsyncResponseWriter< ::google::protobuf::Empty>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Get() { ::grpc::Service::MarkMethodAsync(6); } ~WithAsyncMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGet(::grpc::ServerContext* context, ::tunnelbroker::GetRequest* request, ::grpc::ServerAsyncWriter< ::tunnelbroker::GetResponse>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithAsyncMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_MessagesStream() { ::grpc::Service::MarkMethodAsync(7); } ~WithAsyncMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMessagesStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); } }; typedef WithAsyncMethod_CheckIfPrimaryDeviceOnline > > > > > > > AsyncService; template class WithCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::CheckRequest, ::tunnelbroker::CheckResponse>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::CheckRequest* request, ::tunnelbroker::CheckResponse* response) { return this->CheckIfPrimaryDeviceOnline(context, request, response); }));} void SetMessageAllocatorFor_CheckIfPrimaryDeviceOnline( ::grpc::MessageAllocator< ::tunnelbroker::CheckRequest, ::tunnelbroker::CheckResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::CheckRequest, ::tunnelbroker::CheckResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CheckIfPrimaryDeviceOnline( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::NewPrimaryRequest, ::tunnelbroker::NewPrimaryResponse>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::NewPrimaryRequest* request, ::tunnelbroker::NewPrimaryResponse* response) { return this->BecomeNewPrimaryDevice(context, request, response); }));} void SetMessageAllocatorFor_BecomeNewPrimaryDevice( ::grpc::MessageAllocator< ::tunnelbroker::NewPrimaryRequest, ::tunnelbroker::NewPrimaryResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::NewPrimaryRequest, ::tunnelbroker::NewPrimaryResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BecomeNewPrimaryDevice( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SendPong() { ::grpc::Service::MarkMethodCallback(2, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::PongRequest, ::google::protobuf::Empty>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::PongRequest* request, ::google::protobuf::Empty* response) { return this->SendPong(context, request, response); }));} void SetMessageAllocatorFor_SendPong( ::grpc::MessageAllocator< ::tunnelbroker::PongRequest, ::google::protobuf::Empty>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::PongRequest, ::google::protobuf::Empty>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendPong( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } }; template class WithCallbackMethod_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_SessionSignature() { ::grpc::Service::MarkMethodCallback(3, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::SessionSignatureRequest, ::tunnelbroker::SessionSignatureResponse>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::SessionSignatureRequest* request, ::tunnelbroker::SessionSignatureResponse* response) { return this->SessionSignature(context, request, response); }));} void SetMessageAllocatorFor_SessionSignature( ::grpc::MessageAllocator< ::tunnelbroker::SessionSignatureRequest, ::tunnelbroker::SessionSignatureResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(3); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::SessionSignatureRequest, ::tunnelbroker::SessionSignatureResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SessionSignature( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_NewSession() { ::grpc::Service::MarkMethodCallback(4, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::NewSessionRequest, ::tunnelbroker::NewSessionResponse>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::NewSessionRequest* request, ::tunnelbroker::NewSessionResponse* response) { return this->NewSession(context, request, response); }));} void SetMessageAllocatorFor_NewSession( ::grpc::MessageAllocator< ::tunnelbroker::NewSessionRequest, ::tunnelbroker::NewSessionResponse>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(4); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::NewSessionRequest, ::tunnelbroker::NewSessionResponse>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NewSession( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Send() { ::grpc::Service::MarkMethodCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::SendRequest, ::google::protobuf::Empty>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::SendRequest* request, ::google::protobuf::Empty* response) { return this->Send(context, request, response); }));} void SetMessageAllocatorFor_Send( ::grpc::MessageAllocator< ::tunnelbroker::SendRequest, ::google::protobuf::Empty>* allocator) { ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(5); static_cast<::grpc::internal::CallbackUnaryHandler< ::tunnelbroker::SendRequest, ::google::protobuf::Empty>*>(handler) ->SetMessageAllocator(allocator); } ~WithCallbackMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Send( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) { return nullptr; } }; template class WithCallbackMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_Get() { ::grpc::Service::MarkMethodCallback(6, new ::grpc::internal::CallbackServerStreamingHandler< ::tunnelbroker::GetRequest, ::tunnelbroker::GetResponse>( [this]( ::grpc::CallbackServerContext* context, const ::tunnelbroker::GetRequest* request) { return this->Get(context, request); })); } ~WithCallbackMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::tunnelbroker::GetResponse>* Get( ::grpc::CallbackServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/) { return nullptr; } }; template class WithCallbackMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithCallbackMethod_MessagesStream() { ::grpc::Service::MarkMethodCallback(7, new ::grpc::internal::CallbackBidiHandler< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>( [this]( ::grpc::CallbackServerContext* context) { return this->MessagesStream(context); })); } ~WithCallbackMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::tunnelbroker::MessageToTunnelbroker, ::tunnelbroker::MessageToClient>* MessagesStream( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; typedef WithCallbackMethod_CheckIfPrimaryDeviceOnline > > > > > > > CallbackService; typedef CallbackService ExperimentalCallbackService; template class WithGenericMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodGeneric(0); } ~WithGenericMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodGeneric(1); } ~WithGenericMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SendPong() { ::grpc::Service::MarkMethodGeneric(2); } ~WithGenericMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_SessionSignature() { ::grpc::Service::MarkMethodGeneric(3); } ~WithGenericMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_NewSession() { ::grpc::Service::MarkMethodGeneric(4); } ~WithGenericMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Send() { ::grpc::Service::MarkMethodGeneric(5); } ~WithGenericMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Get() { ::grpc::Service::MarkMethodGeneric(6); } ~WithGenericMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithGenericMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_MessagesStream() { ::grpc::Service::MarkMethodGeneric(7); } ~WithGenericMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template class WithRawMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodRaw(0); } ~WithRawMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCheckIfPrimaryDeviceOnline(::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(0, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodRaw(1); } ~WithRawMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestBecomeNewPrimaryDevice(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SendPong() { ::grpc::Service::MarkMethodRaw(2); } ~WithRawMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSendPong(::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_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_SessionSignature() { ::grpc::Service::MarkMethodRaw(3); } ~WithRawMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSessionSignature(::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_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_NewSession() { ::grpc::Service::MarkMethodRaw(4); } ~WithRawMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestNewSession(::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 WithRawMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Send() { ::grpc::Service::MarkMethodRaw(5); } ~WithRawMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestSend(::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(5, context, request, response, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Get() { ::grpc::Service::MarkMethodRaw(6); } ~WithRawMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGet(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncServerStreaming(6, context, request, writer, new_call_cq, notification_cq, tag); } }; template class WithRawMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_MessagesStream() { ::grpc::Service::MarkMethodRaw(7); } ~WithRawMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestMessagesStream(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncBidiStreaming(7, context, stream, new_call_cq, notification_cq, tag); } }; template class WithRawCallbackMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodRawCallback(0, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->CheckIfPrimaryDeviceOnline(context, request, response); })); } ~WithRawCallbackMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* CheckIfPrimaryDeviceOnline( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodRawCallback(1, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->BecomeNewPrimaryDevice(context, request, response); })); } ~WithRawCallbackMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* BecomeNewPrimaryDevice( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SendPong() { ::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->SendPong(context, request, response); })); } ~WithRawCallbackMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SendPong( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_SessionSignature() { ::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->SessionSignature(context, request, response); })); } ~WithRawCallbackMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* SessionSignature( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_NewSession() { ::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->NewSession(context, request, response); })); } ~WithRawCallbackMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* NewSession( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Send() { ::grpc::Service::MarkMethodRawCallback(5, new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->Send(context, request, response); })); } ~WithRawCallbackMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerUnaryReactor* Send( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/) { return nullptr; } }; template class WithRawCallbackMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_Get() { ::grpc::Service::MarkMethodRawCallback(6, new ::grpc::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context, const::grpc::ByteBuffer* request) { return this->Get(context, request); })); } ~WithRawCallbackMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerWriteReactor< ::grpc::ByteBuffer>* Get( ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/) { return nullptr; } }; template class WithRawCallbackMethod_MessagesStream : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawCallbackMethod_MessagesStream() { ::grpc::Service::MarkMethodRawCallback(7, new ::grpc::internal::CallbackBidiHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this]( ::grpc::CallbackServerContext* context) { return this->MessagesStream(context); })); } ~WithRawCallbackMethod_MessagesStream() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method ::grpc::Status MessagesStream(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< ::tunnelbroker::MessageToClient, ::tunnelbroker::MessageToTunnelbroker>* /*stream*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual ::grpc::ServerBidiReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* MessagesStream( ::grpc::CallbackServerContext* /*context*/) { return nullptr; } }; template class WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline() { ::grpc::Service::MarkMethodStreamed(0, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::CheckRequest, ::tunnelbroker::CheckResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::CheckRequest, ::tunnelbroker::CheckResponse>* streamer) { return this->StreamedCheckIfPrimaryDeviceOnline(context, streamer); })); } ~WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status CheckIfPrimaryDeviceOnline(::grpc::ServerContext* /*context*/, const ::tunnelbroker::CheckRequest* /*request*/, ::tunnelbroker::CheckResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedCheckIfPrimaryDeviceOnline(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::CheckRequest,::tunnelbroker::CheckResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_BecomeNewPrimaryDevice : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_BecomeNewPrimaryDevice() { ::grpc::Service::MarkMethodStreamed(1, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::NewPrimaryRequest, ::tunnelbroker::NewPrimaryResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::NewPrimaryRequest, ::tunnelbroker::NewPrimaryResponse>* streamer) { return this->StreamedBecomeNewPrimaryDevice(context, streamer); })); } ~WithStreamedUnaryMethod_BecomeNewPrimaryDevice() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status BecomeNewPrimaryDevice(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewPrimaryRequest* /*request*/, ::tunnelbroker::NewPrimaryResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedBecomeNewPrimaryDevice(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::NewPrimaryRequest,::tunnelbroker::NewPrimaryResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SendPong : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SendPong() { ::grpc::Service::MarkMethodStreamed(2, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::PongRequest, ::google::protobuf::Empty>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::PongRequest, ::google::protobuf::Empty>* streamer) { return this->StreamedSendPong(context, streamer); })); } ~WithStreamedUnaryMethod_SendPong() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SendPong(::grpc::ServerContext* /*context*/, const ::tunnelbroker::PongRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSendPong(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::PongRequest,::google::protobuf::Empty>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_SessionSignature : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_SessionSignature() { ::grpc::Service::MarkMethodStreamed(3, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::SessionSignatureRequest, ::tunnelbroker::SessionSignatureResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::SessionSignatureRequest, ::tunnelbroker::SessionSignatureResponse>* streamer) { return this->StreamedSessionSignature(context, streamer); })); } ~WithStreamedUnaryMethod_SessionSignature() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status SessionSignature(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SessionSignatureRequest* /*request*/, ::tunnelbroker::SessionSignatureResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSessionSignature(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::SessionSignatureRequest,::tunnelbroker::SessionSignatureResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_NewSession : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_NewSession() { ::grpc::Service::MarkMethodStreamed(4, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::NewSessionRequest, ::tunnelbroker::NewSessionResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::NewSessionRequest, ::tunnelbroker::NewSessionResponse>* streamer) { return this->StreamedNewSession(context, streamer); })); } ~WithStreamedUnaryMethod_NewSession() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status NewSession(::grpc::ServerContext* /*context*/, const ::tunnelbroker::NewSessionRequest* /*request*/, ::tunnelbroker::NewSessionResponse* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedNewSession(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::NewSessionRequest,::tunnelbroker::NewSessionResponse>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Send : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Send() { ::grpc::Service::MarkMethodStreamed(5, new ::grpc::internal::StreamedUnaryHandler< ::tunnelbroker::SendRequest, ::google::protobuf::Empty>( [this](::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::SendRequest, ::google::protobuf::Empty>* streamer) { return this->StreamedSend(context, streamer); })); } ~WithStreamedUnaryMethod_Send() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Send(::grpc::ServerContext* /*context*/, const ::tunnelbroker::SendRequest* /*request*/, ::google::protobuf::Empty* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary virtual ::grpc::Status StreamedSend(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::tunnelbroker::SendRequest,::google::protobuf::Empty>* server_unary_streamer) = 0; }; typedef WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline > > > > > StreamedUnaryService; template class WithSplitStreamingMethod_Get : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithSplitStreamingMethod_Get() { ::grpc::Service::MarkMethodStreamed(6, new ::grpc::internal::SplitServerStreamingHandler< ::tunnelbroker::GetRequest, ::tunnelbroker::GetResponse>( [this](::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::tunnelbroker::GetRequest, ::tunnelbroker::GetResponse>* streamer) { return this->StreamedGet(context, streamer); })); } ~WithSplitStreamingMethod_Get() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method ::grpc::Status Get(::grpc::ServerContext* /*context*/, const ::tunnelbroker::GetRequest* /*request*/, ::grpc::ServerWriter< ::tunnelbroker::GetResponse>* /*writer*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with split streamed virtual ::grpc::Status StreamedGet(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::tunnelbroker::GetRequest,::tunnelbroker::GetResponse>* server_split_streamer) = 0; }; typedef WithSplitStreamingMethod_Get SplitStreamedService; typedef WithStreamedUnaryMethod_CheckIfPrimaryDeviceOnline > > > > > > StreamedService; }; } // namespace tunnelbroker #endif // GRPC_tunnelbroker_2eproto__INCLUDED diff --git a/shared/protos/_generated/tunnelbroker.pb.cc b/shared/protos/_generated/tunnelbroker.pb.cc index 516e47109..30eca25f2 100644 --- a/shared/protos/_generated/tunnelbroker.pb.cc +++ b/shared/protos/_generated/tunnelbroker.pb.cc @@ -1,6060 +1,6020 @@ // @generated by the protocol buffer compiler. DO NOT EDIT! // source: tunnelbroker.proto #include "tunnelbroker.pb.h" #include #include #include #include #include #include #include #include // @@protoc_insertion_point(includes) #include PROTOBUF_PRAGMA_INIT_SEG namespace tunnelbroker { constexpr SessionSignatureRequest::SessionSignatureRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct SessionSignatureRequestDefaultTypeInternal { constexpr SessionSignatureRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SessionSignatureRequestDefaultTypeInternal() {} union { SessionSignatureRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SessionSignatureRequestDefaultTypeInternal _SessionSignatureRequest_default_instance_; constexpr SessionSignatureResponse::SessionSignatureResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : tosign_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct SessionSignatureResponseDefaultTypeInternal { constexpr SessionSignatureResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SessionSignatureResponseDefaultTypeInternal() {} union { SessionSignatureResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SessionSignatureResponseDefaultTypeInternal _SessionSignatureResponse_default_instance_; constexpr NewSessionRequest::NewSessionRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : deviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , publickey_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , signature_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , notifytoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , deviceappversion_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , deviceos_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , devicetype_(0) {} struct NewSessionRequestDefaultTypeInternal { constexpr NewSessionRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NewSessionRequestDefaultTypeInternal() {} union { NewSessionRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NewSessionRequestDefaultTypeInternal _NewSessionRequest_default_instance_; constexpr NewSessionResponse::NewSessionResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : sessionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct NewSessionResponseDefaultTypeInternal { constexpr NewSessionResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NewSessionResponseDefaultTypeInternal() {} union { NewSessionResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_; constexpr SendRequest::SendRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() , sessionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct SendRequestDefaultTypeInternal { constexpr SendRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~SendRequestDefaultTypeInternal() {} union { SendRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SendRequestDefaultTypeInternal _SendRequest_default_instance_; constexpr GetRequest::GetRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : sessionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , newnotifytoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct GetRequestDefaultTypeInternal { constexpr GetRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~GetRequestDefaultTypeInternal() {} union { GetRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetRequestDefaultTypeInternal _GetRequest_default_instance_; constexpr GetResponseMessage::GetResponseMessage( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct GetResponseMessageDefaultTypeInternal { constexpr GetResponseMessageDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~GetResponseMessageDefaultTypeInternal() {} union { GetResponseMessage _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseMessageDefaultTypeInternal _GetResponseMessage_default_instance_; constexpr GetResponse::GetResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} struct GetResponseDefaultTypeInternal { constexpr GetResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~GetResponseDefaultTypeInternal() {} union { GetResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GetResponseDefaultTypeInternal _GetResponse_default_instance_; constexpr ProcessedMessages::ProcessedMessages( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : messageid_(){} struct ProcessedMessagesDefaultTypeInternal { constexpr ProcessedMessagesDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~ProcessedMessagesDefaultTypeInternal() {} union { ProcessedMessages _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProcessedMessagesDefaultTypeInternal _ProcessedMessages_default_instance_; constexpr MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() , messageid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , todeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct MessageToTunnelbrokerStructDefaultTypeInternal { constexpr MessageToTunnelbrokerStructDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessageToTunnelbrokerStructDefaultTypeInternal() {} union { MessageToTunnelbrokerStruct _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToTunnelbrokerStructDefaultTypeInternal _MessageToTunnelbrokerStruct_default_instance_; constexpr MessagesToSend::MessagesToSend( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : messages_(){} struct MessagesToSendDefaultTypeInternal { constexpr MessagesToSendDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessagesToSendDefaultTypeInternal() {} union { MessagesToSend _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessagesToSendDefaultTypeInternal _MessagesToSend_default_instance_; constexpr MessageToTunnelbroker::MessageToTunnelbroker( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : sessionid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , _oneof_case_{}{} + : _oneof_case_{}{} struct MessageToTunnelbrokerDefaultTypeInternal { constexpr MessageToTunnelbrokerDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessageToTunnelbrokerDefaultTypeInternal() {} union { MessageToTunnelbroker _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToTunnelbrokerDefaultTypeInternal _MessageToTunnelbroker_default_instance_; constexpr MessageToClientStruct::MessageToClientStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : blobhashes_() , messageid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , fromdeviceid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , payload_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct MessageToClientStructDefaultTypeInternal { constexpr MessageToClientStructDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessageToClientStructDefaultTypeInternal() {} union { MessageToClientStruct _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToClientStructDefaultTypeInternal _MessageToClientStruct_default_instance_; constexpr MessagesToDeliver::MessagesToDeliver( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : messages_(){} struct MessagesToDeliverDefaultTypeInternal { constexpr MessagesToDeliverDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessagesToDeliverDefaultTypeInternal() {} union { MessagesToDeliver _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessagesToDeliverDefaultTypeInternal _MessagesToDeliver_default_instance_; constexpr MessageToClient::MessageToClient( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} struct MessageToClientDefaultTypeInternal { constexpr MessageToClientDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~MessageToClientDefaultTypeInternal() {} union { MessageToClient _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MessageToClientDefaultTypeInternal _MessageToClient_default_instance_; constexpr CheckRequest::CheckRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , devicetoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct CheckRequestDefaultTypeInternal { constexpr CheckRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~CheckRequestDefaultTypeInternal() {} union { CheckRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CheckRequestDefaultTypeInternal _CheckRequest_default_instance_; constexpr CheckResponse::CheckResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : checkresponsetype_(0) {} struct CheckResponseDefaultTypeInternal { constexpr CheckResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~CheckResponseDefaultTypeInternal() {} union { CheckResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CheckResponseDefaultTypeInternal _CheckResponse_default_instance_; constexpr NewPrimaryRequest::NewPrimaryRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , devicetoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct NewPrimaryRequestDefaultTypeInternal { constexpr NewPrimaryRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NewPrimaryRequestDefaultTypeInternal() {} union { NewPrimaryRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_; constexpr NewPrimaryResponse::NewPrimaryResponse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : success_(false){} struct NewPrimaryResponseDefaultTypeInternal { constexpr NewPrimaryResponseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~NewPrimaryResponseDefaultTypeInternal() {} union { NewPrimaryResponse _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NewPrimaryResponseDefaultTypeInternal _NewPrimaryResponse_default_instance_; constexpr PongRequest::PongRequest( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , devicetoken_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} struct PongRequestDefaultTypeInternal { constexpr PongRequestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} ~PongRequestDefaultTypeInternal() {} union { PongRequest _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PongRequestDefaultTypeInternal _PongRequest_default_instance_; } // namespace tunnelbroker static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_tunnelbroker_2eproto[20]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_tunnelbroker_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_tunnelbroker_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_tunnelbroker_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SessionSignatureRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SessionSignatureRequest, deviceid_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SessionSignatureResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SessionSignatureResponse, tosign_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, _has_bits_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, deviceid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, publickey_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, signature_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, notifytoken_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, devicetype_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, deviceappversion_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionRequest, deviceos_), ~0u, ~0u, ~0u, 0, ~0u, ~0u, ~0u, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewSessionResponse, sessionid_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SendRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::SendRequest, sessionid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::SendRequest, todeviceid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::SendRequest, payload_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::SendRequest, blobhashes_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetRequest, _has_bits_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetRequest, sessionid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetRequest, newnotifytoken_), ~0u, 0, ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponseMessage, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponseMessage, fromdeviceid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponseMessage, payload_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponseMessage, blobhashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::GetResponse, _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(::tunnelbroker::GetResponse, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::ProcessedMessages, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::ProcessedMessages, messageid_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, messageid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, todeviceid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, payload_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbrokerStruct, blobhashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToSend, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToSend, messages_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, sessionid_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToTunnelbroker, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, messageid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, fromdeviceid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, payload_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClientStruct, blobhashes_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToDeliver, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessagesToDeliver, messages_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::tunnelbroker::MessageToClient, data_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, userid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckRequest, devicetoken_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::CheckResponse, checkresponsetype_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewPrimaryRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewPrimaryRequest, userid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewPrimaryRequest, devicetoken_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewPrimaryResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::NewPrimaryResponse, success_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::PongRequest, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::tunnelbroker::PongRequest, userid_), PROTOBUF_FIELD_OFFSET(::tunnelbroker::PongRequest, devicetoken_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::tunnelbroker::SessionSignatureRequest)}, { 6, -1, sizeof(::tunnelbroker::SessionSignatureResponse)}, { 12, 24, sizeof(::tunnelbroker::NewSessionRequest)}, { 31, -1, sizeof(::tunnelbroker::NewSessionResponse)}, { 37, -1, sizeof(::tunnelbroker::SendRequest)}, { 46, 53, sizeof(::tunnelbroker::GetRequest)}, { 55, -1, sizeof(::tunnelbroker::GetResponseMessage)}, { 63, -1, sizeof(::tunnelbroker::GetResponse)}, { 72, -1, sizeof(::tunnelbroker::ProcessedMessages)}, { 78, -1, sizeof(::tunnelbroker::MessageToTunnelbrokerStruct)}, { 87, -1, sizeof(::tunnelbroker::MessagesToSend)}, { 93, -1, sizeof(::tunnelbroker::MessageToTunnelbroker)}, - { 103, -1, sizeof(::tunnelbroker::MessageToClientStruct)}, - { 112, -1, sizeof(::tunnelbroker::MessagesToDeliver)}, - { 118, -1, sizeof(::tunnelbroker::MessageToClient)}, - { 128, -1, sizeof(::tunnelbroker::CheckRequest)}, - { 135, -1, sizeof(::tunnelbroker::CheckResponse)}, - { 141, -1, sizeof(::tunnelbroker::NewPrimaryRequest)}, - { 148, -1, sizeof(::tunnelbroker::NewPrimaryResponse)}, - { 154, -1, sizeof(::tunnelbroker::PongRequest)}, + { 102, -1, sizeof(::tunnelbroker::MessageToClientStruct)}, + { 111, -1, sizeof(::tunnelbroker::MessagesToDeliver)}, + { 117, -1, sizeof(::tunnelbroker::MessageToClient)}, + { 127, -1, sizeof(::tunnelbroker::CheckRequest)}, + { 134, -1, sizeof(::tunnelbroker::CheckResponse)}, + { 140, -1, sizeof(::tunnelbroker::NewPrimaryRequest)}, + { 147, -1, sizeof(::tunnelbroker::NewPrimaryResponse)}, + { 153, -1, sizeof(::tunnelbroker::PongRequest)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::tunnelbroker::_SessionSignatureRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_SessionSignatureResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_NewSessionRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_NewSessionResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_SendRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_GetRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_GetResponseMessage_default_instance_), reinterpret_cast(&::tunnelbroker::_GetResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_ProcessedMessages_default_instance_), reinterpret_cast(&::tunnelbroker::_MessageToTunnelbrokerStruct_default_instance_), reinterpret_cast(&::tunnelbroker::_MessagesToSend_default_instance_), reinterpret_cast(&::tunnelbroker::_MessageToTunnelbroker_default_instance_), reinterpret_cast(&::tunnelbroker::_MessageToClientStruct_default_instance_), reinterpret_cast(&::tunnelbroker::_MessagesToDeliver_default_instance_), reinterpret_cast(&::tunnelbroker::_MessageToClient_default_instance_), reinterpret_cast(&::tunnelbroker::_CheckRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_CheckResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_NewPrimaryRequest_default_instance_), reinterpret_cast(&::tunnelbroker::_NewPrimaryResponse_default_instance_), reinterpret_cast(&::tunnelbroker::_PongRequest_default_instance_), }; const char descriptor_table_protodef_tunnelbroker_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\022tunnelbroker.proto\022\014tunnelbroker\032\033goog" "le/protobuf/empty.proto\"+\n\027SessionSignat" "ureRequest\022\020\n\010deviceID\030\001 \001(\t\"*\n\030SessionS" "ignatureResponse\022\016\n\006toSign\030\001 \001(\t\"\225\002\n\021New" "SessionRequest\022\020\n\010deviceID\030\001 \001(\t\022\021\n\tpubl" "icKey\030\002 \001(\t\022\021\n\tsignature\030\003 \001(\t\022\030\n\013notify" "Token\030\004 \001(\tH\000\210\001\001\022\?\n\ndeviceType\030\005 \001(\0162+.t" "unnelbroker.NewSessionRequest.DeviceType" "s\022\030\n\020deviceAppVersion\030\006 \001(\t\022\020\n\010deviceOS\030" "\007 \001(\t\"1\n\013DeviceTypes\022\n\n\006MOBILE\020\000\022\007\n\003WEB\020" "\001\022\r\n\tKEYSERVER\020\002B\016\n\014_notifyToken\"\'\n\022NewS" "essionResponse\022\021\n\tsessionID\030\001 \001(\t\"Y\n\013Sen" "dRequest\022\021\n\tsessionID\030\001 \001(\t\022\022\n\ntoDeviceI" "D\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\022\022\n\nblobHashes\030\004" " \003(\t\"O\n\nGetRequest\022\021\n\tsessionID\030\001 \001(\t\022\033\n" "\016newNotifyToken\030\002 \001(\tH\000\210\001\001B\021\n\017_newNotify" "Token\"O\n\022GetResponseMessage\022\024\n\014fromDevic" "eID\030\001 \001(\t\022\017\n\007payload\030\002 \001(\014\022\022\n\nblobHashes" "\030\003 \003(\t\"\264\001\n\013GetResponse\022;\n\017responseMessag" "e\030\001 \001(\0132 .tunnelbroker.GetResponseMessag" "eH\000\022&\n\004ping\030\002 \001(\0132\026.google.protobuf.Empt" "yH\000\0228\n\026newNotifyTokenRequired\030\003 \001(\0132\026.go" "ogle.protobuf.EmptyH\000B\006\n\004data\"&\n\021Process" "edMessages\022\021\n\tmessageID\030\001 \003(\t\"i\n\033Message" "ToTunnelbrokerStruct\022\021\n\tmessageID\030\001 \001(\t\022" "\022\n\ntoDeviceID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\n" "blobHashes\030\004 \003(\t\"M\n\016MessagesToSend\022;\n\010me" "ssages\030\001 \003(\0132).tunnelbroker.MessageToTun" - "nelbrokerStruct\"\302\001\n\025MessageToTunnelbroke" - "r\022\021\n\tsessionID\030\001 \001(\t\0226\n\016messagesToSend\030\002" - " \001(\0132\034.tunnelbroker.MessagesToSendH\000\022<\n\021" - "processedMessages\030\003 \001(\0132\037.tunnelbroker.P" - "rocessedMessagesH\000\022\030\n\016newNotifyToken\030\004 \001" - "(\tH\000B\006\n\004data\"e\n\025MessageToClientStruct\022\021\n" - "\tmessageID\030\001 \001(\t\022\024\n\014fromDeviceID\030\002 \001(\t\022\017" - "\n\007payload\030\003 \001(\t\022\022\n\nblobHashes\030\004 \003(\t\"J\n\021M" - "essagesToDeliver\0225\n\010messages\030\001 \003(\0132#.tun" - "nelbroker.MessageToClientStruct\"\367\001\n\017Mess" - "ageToClient\022<\n\021messagesToDeliver\030\001 \001(\0132\037" - ".tunnelbroker.MessagesToDeliverH\000\022<\n\021pro" - "cessedMessages\030\002 \001(\0132\037.tunnelbroker.Proc" - "essedMessagesH\000\0228\n\026newNotifyTokenRequire" - "d\030\003 \001(\0132\026.google.protobuf.EmptyH\000\022&\n\004pin" - "g\030\004 \001(\0132\026.google.protobuf.EmptyH\000B\006\n\004dat" - "a\"3\n\014CheckRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013dev" - "iceToken\030\002 \001(\t\"K\n\rCheckResponse\022:\n\021check" - "ResponseType\030\001 \001(\0162\037.tunnelbroker.CheckR" - "esponseType\"8\n\021NewPrimaryRequest\022\016\n\006user" - "Id\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"%\n\022NewPrim" - "aryResponse\022\017\n\007success\030\001 \001(\010\"2\n\013PongRequ" - "est\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t" - "*n\n\021CheckResponseType\022\030\n\024PRIMARY_DOESNT_" - "EXIST\020\000\022\022\n\016PRIMARY_ONLINE\020\001\022\023\n\017PRIMARY_O" - "FFLINE\020\002\022\026\n\022CURRENT_IS_PRIMARY\020\0032\237\005\n\023Tun" - "nelbrokerService\022W\n\032CheckIfPrimaryDevice" - "Online\022\032.tunnelbroker.CheckRequest\032\033.tun" - "nelbroker.CheckResponse\"\000\022]\n\026BecomeNewPr" - "imaryDevice\022\037.tunnelbroker.NewPrimaryReq" - "uest\032 .tunnelbroker.NewPrimaryResponse\"\000" - "\022\?\n\010SendPong\022\031.tunnelbroker.PongRequest\032" - "\026.google.protobuf.Empty\"\000\022c\n\020SessionSign" - "ature\022%.tunnelbroker.SessionSignatureReq" - "uest\032&.tunnelbroker.SessionSignatureResp" - "onse\"\000\022Q\n\nNewSession\022\037.tunnelbroker.NewS" - "essionRequest\032 .tunnelbroker.NewSessionR" - "esponse\"\000\022;\n\004Send\022\031.tunnelbroker.SendReq" - "uest\032\026.google.protobuf.Empty\"\000\022>\n\003Get\022\030." - "tunnelbroker.GetRequest\032\031.tunnelbroker.G" - "etResponse\"\0000\001\022Z\n\016MessagesStream\022#.tunne" - "lbroker.MessageToTunnelbroker\032\035.tunnelbr" - "oker.MessageToClient\"\000(\0010\001b\006proto3" + "nelbrokerStruct\"\257\001\n\025MessageToTunnelbroke" + "r\0226\n\016messagesToSend\030\001 \001(\0132\034.tunnelbroker" + ".MessagesToSendH\000\022<\n\021processedMessages\030\002" + " \001(\0132\037.tunnelbroker.ProcessedMessagesH\000\022" + "\030\n\016newNotifyToken\030\003 \001(\tH\000B\006\n\004data\"e\n\025Mes" + "sageToClientStruct\022\021\n\tmessageID\030\001 \001(\t\022\024\n" + "\014fromDeviceID\030\002 \001(\t\022\017\n\007payload\030\003 \001(\t\022\022\n\n" + "blobHashes\030\004 \003(\t\"J\n\021MessagesToDeliver\0225\n" + "\010messages\030\001 \003(\0132#.tunnelbroker.MessageTo" + "ClientStruct\"\367\001\n\017MessageToClient\022<\n\021mess" + "agesToDeliver\030\001 \001(\0132\037.tunnelbroker.Messa" + "gesToDeliverH\000\022<\n\021processedMessages\030\002 \001(" + "\0132\037.tunnelbroker.ProcessedMessagesH\000\0228\n\026" + "newNotifyTokenRequired\030\003 \001(\0132\026.google.pr" + "otobuf.EmptyH\000\022&\n\004ping\030\004 \001(\0132\026.google.pr" + "otobuf.EmptyH\000B\006\n\004data\"3\n\014CheckRequest\022\016" + "\n\006userId\030\001 \001(\t\022\023\n\013deviceToken\030\002 \001(\t\"K\n\rC" + "heckResponse\022:\n\021checkResponseType\030\001 \001(\0162" + "\037.tunnelbroker.CheckResponseType\"8\n\021NewP" + "rimaryRequest\022\016\n\006userId\030\001 \001(\t\022\023\n\013deviceT" + "oken\030\002 \001(\t\"%\n\022NewPrimaryResponse\022\017\n\007succ" + "ess\030\001 \001(\010\"2\n\013PongRequest\022\016\n\006userId\030\001 \001(\t" + "\022\023\n\013deviceToken\030\002 \001(\t*n\n\021CheckResponseTy" + "pe\022\030\n\024PRIMARY_DOESNT_EXIST\020\000\022\022\n\016PRIMARY_" + "ONLINE\020\001\022\023\n\017PRIMARY_OFFLINE\020\002\022\026\n\022CURRENT" + "_IS_PRIMARY\020\0032\237\005\n\023TunnelbrokerService\022W\n" + "\032CheckIfPrimaryDeviceOnline\022\032.tunnelbrok" + "er.CheckRequest\032\033.tunnelbroker.CheckResp" + "onse\"\000\022]\n\026BecomeNewPrimaryDevice\022\037.tunne" + "lbroker.NewPrimaryRequest\032 .tunnelbroker" + ".NewPrimaryResponse\"\000\022\?\n\010SendPong\022\031.tunn" + "elbroker.PongRequest\032\026.google.protobuf.E" + "mpty\"\000\022c\n\020SessionSignature\022%.tunnelbroke" + "r.SessionSignatureRequest\032&.tunnelbroker" + ".SessionSignatureResponse\"\000\022Q\n\nNewSessio" + "n\022\037.tunnelbroker.NewSessionRequest\032 .tun" + "nelbroker.NewSessionResponse\"\000\022;\n\004Send\022\031" + ".tunnelbroker.SendRequest\032\026.google.proto" + "buf.Empty\"\000\022>\n\003Get\022\030.tunnelbroker.GetReq" + "uest\032\031.tunnelbroker.GetResponse\"\0000\001\022Z\n\016M" + "essagesStream\022#.tunnelbroker.MessageToTu" + "nnelbroker\032\035.tunnelbroker.MessageToClien" + "t\"\000(\0010\001b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_tunnelbroker_2eproto_deps[1] = { &::descriptor_table_google_2fprotobuf_2fempty_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_tunnelbroker_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tunnelbroker_2eproto = { - false, false, 2834, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", + false, false, 2815, descriptor_table_protodef_tunnelbroker_2eproto, "tunnelbroker.proto", &descriptor_table_tunnelbroker_2eproto_once, descriptor_table_tunnelbroker_2eproto_deps, 1, 20, schemas, file_default_instances, TableStruct_tunnelbroker_2eproto::offsets, file_level_metadata_tunnelbroker_2eproto, file_level_enum_descriptors_tunnelbroker_2eproto, file_level_service_descriptors_tunnelbroker_2eproto, }; PROTOBUF_ATTRIBUTE_WEAK ::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_tunnelbroker_2eproto_metadata_getter(int index) { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_tunnelbroker_2eproto); return descriptor_table_tunnelbroker_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_tunnelbroker_2eproto(&descriptor_table_tunnelbroker_2eproto); namespace tunnelbroker { const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NewSessionRequest_DeviceTypes_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_tunnelbroker_2eproto); return file_level_enum_descriptors_tunnelbroker_2eproto[0]; } bool NewSessionRequest_DeviceTypes_IsValid(int value) { switch (value) { case 0: case 1: case 2: return true; default: return false; } } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) constexpr NewSessionRequest_DeviceTypes NewSessionRequest::MOBILE; constexpr NewSessionRequest_DeviceTypes NewSessionRequest::WEB; constexpr NewSessionRequest_DeviceTypes NewSessionRequest::KEYSERVER; constexpr NewSessionRequest_DeviceTypes NewSessionRequest::DeviceTypes_MIN; constexpr NewSessionRequest_DeviceTypes NewSessionRequest::DeviceTypes_MAX; constexpr int NewSessionRequest::DeviceTypes_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CheckResponseType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_tunnelbroker_2eproto); return file_level_enum_descriptors_tunnelbroker_2eproto[1]; } bool CheckResponseType_IsValid(int value) { switch (value) { case 0: case 1: case 2: case 3: return true; default: return false; } } // =================================================================== class SessionSignatureRequest::_Internal { public: }; SessionSignatureRequest::SessionSignatureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.SessionSignatureRequest) } SessionSignatureRequest::SessionSignatureRequest(const SessionSignatureRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); 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:tunnelbroker.SessionSignatureRequest) } void SessionSignatureRequest::SharedCtor() { deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } SessionSignatureRequest::~SessionSignatureRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.SessionSignatureRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void SessionSignatureRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SessionSignatureRequest::ArenaDtor(void* object) { SessionSignatureRequest* _this = reinterpret_cast< SessionSignatureRequest* >(object); (void)_this; } void SessionSignatureRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SessionSignatureRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void SessionSignatureRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.SessionSignatureRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; deviceid_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SessionSignatureRequest::_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 deviceID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_deviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.SessionSignatureRequest.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* SessionSignatureRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.SessionSignatureRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string deviceID = 1; 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, "tunnelbroker.SessionSignatureRequest.deviceID"); target = stream->WriteStringMaybeAliased( 1, 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:tunnelbroker.SessionSignatureRequest) return target; } size_t SessionSignatureRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.SessionSignatureRequest) 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 deviceID = 1; 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 SessionSignatureRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.SessionSignatureRequest) GOOGLE_DCHECK_NE(&from, this); const SessionSignatureRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.SessionSignatureRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.SessionSignatureRequest) MergeFrom(*source); } } void SessionSignatureRequest::MergeFrom(const SessionSignatureRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.SessionSignatureRequest) 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.deviceid().size() > 0) { _internal_set_deviceid(from._internal_deviceid()); } } void SessionSignatureRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.SessionSignatureRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SessionSignatureRequest::CopyFrom(const SessionSignatureRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.SessionSignatureRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool SessionSignatureRequest::IsInitialized() const { return true; } void SessionSignatureRequest::InternalSwap(SessionSignatureRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata SessionSignatureRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class SessionSignatureResponse::_Internal { public: }; SessionSignatureResponse::SessionSignatureResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.SessionSignatureResponse) } SessionSignatureResponse::SessionSignatureResponse(const SessionSignatureResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); tosign_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_tosign().empty()) { tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_tosign(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.SessionSignatureResponse) } void SessionSignatureResponse::SharedCtor() { tosign_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } SessionSignatureResponse::~SessionSignatureResponse() { // @@protoc_insertion_point(destructor:tunnelbroker.SessionSignatureResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void SessionSignatureResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); tosign_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SessionSignatureResponse::ArenaDtor(void* object) { SessionSignatureResponse* _this = reinterpret_cast< SessionSignatureResponse* >(object); (void)_this; } void SessionSignatureResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SessionSignatureResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } void SessionSignatureResponse::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.SessionSignatureResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; tosign_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SessionSignatureResponse::_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 toSign = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_tosign(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.SessionSignatureResponse.toSign")); 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* SessionSignatureResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.SessionSignatureResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string toSign = 1; if (this->tosign().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_tosign().data(), static_cast(this->_internal_tosign().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.SessionSignatureResponse.toSign"); target = stream->WriteStringMaybeAliased( 1, this->_internal_tosign(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.SessionSignatureResponse) return target; } size_t SessionSignatureResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.SessionSignatureResponse) 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 toSign = 1; if (this->tosign().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_tosign()); } 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 SessionSignatureResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.SessionSignatureResponse) GOOGLE_DCHECK_NE(&from, this); const SessionSignatureResponse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.SessionSignatureResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.SessionSignatureResponse) MergeFrom(*source); } } void SessionSignatureResponse::MergeFrom(const SessionSignatureResponse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.SessionSignatureResponse) 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.tosign().size() > 0) { _internal_set_tosign(from._internal_tosign()); } } void SessionSignatureResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.SessionSignatureResponse) if (&from == this) return; Clear(); MergeFrom(from); } void SessionSignatureResponse::CopyFrom(const SessionSignatureResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.SessionSignatureResponse) if (&from == this) return; Clear(); MergeFrom(from); } bool SessionSignatureResponse::IsInitialized() const { return true; } void SessionSignatureResponse::InternalSwap(SessionSignatureResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); tosign_.Swap(&other->tosign_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata SessionSignatureResponse::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class NewSessionRequest::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_notifytoken(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; NewSessionRequest::NewSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.NewSessionRequest) } NewSessionRequest::NewSessionRequest(const NewSessionRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_deviceid().empty()) { deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceid(), GetArena()); } publickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_publickey().empty()) { publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_publickey(), GetArena()); } signature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_signature().empty()) { signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_signature(), GetArena()); } notifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (from._internal_has_notifytoken()) { notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_notifytoken(), GetArena()); } deviceappversion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_deviceappversion().empty()) { deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceappversion(), GetArena()); } deviceos_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_deviceos().empty()) { deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_deviceos(), GetArena()); } devicetype_ = from.devicetype_; // @@protoc_insertion_point(copy_constructor:tunnelbroker.NewSessionRequest) } void NewSessionRequest::SharedCtor() { deviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); publickey_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); signature_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); notifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); deviceappversion_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); deviceos_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetype_ = 0; } NewSessionRequest::~NewSessionRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.NewSessionRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void NewSessionRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); deviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); publickey_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); signature_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); notifytoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); deviceappversion_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); deviceos_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void NewSessionRequest::ArenaDtor(void* object) { NewSessionRequest* _this = reinterpret_cast< NewSessionRequest* >(object); (void)_this; } void NewSessionRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NewSessionRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void NewSessionRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.NewSessionRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; deviceid_.ClearToEmpty(); publickey_.ClearToEmpty(); signature_.ClearToEmpty(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { notifytoken_.ClearNonDefaultToEmpty(); } deviceappversion_.ClearToEmpty(); deviceos_.ClearToEmpty(); devicetype_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NewSessionRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { // string deviceID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_deviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.deviceID")); CHK_(ptr); } else goto handle_unusual; continue; // string publicKey = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_publickey(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.publicKey")); CHK_(ptr); } else goto handle_unusual; continue; // string signature = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_signature(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.signature")); CHK_(ptr); } else goto handle_unusual; continue; // string notifyToken = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { auto str = _internal_mutable_notifytoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.notifyToken")); CHK_(ptr); } else goto handle_unusual; continue; // .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_devicetype(static_cast<::tunnelbroker::NewSessionRequest_DeviceTypes>(val)); } else goto handle_unusual; continue; // string deviceAppVersion = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { auto str = _internal_mutable_deviceappversion(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.deviceAppVersion")); CHK_(ptr); } else goto handle_unusual; continue; // string deviceOS = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { auto str = _internal_mutable_deviceos(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionRequest.deviceOS")); 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: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* NewSessionRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.NewSessionRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string deviceID = 1; 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, "tunnelbroker.NewSessionRequest.deviceID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_deviceid(), target); } // string publicKey = 2; 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, "tunnelbroker.NewSessionRequest.publicKey"); target = stream->WriteStringMaybeAliased( 2, this->_internal_publickey(), target); } // string signature = 3; if (this->signature().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_signature().data(), static_cast(this->_internal_signature().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewSessionRequest.signature"); target = stream->WriteStringMaybeAliased( 3, this->_internal_signature(), target); } // string notifyToken = 4; if (_internal_has_notifytoken()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_notifytoken().data(), static_cast(this->_internal_notifytoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewSessionRequest.notifyToken"); target = stream->WriteStringMaybeAliased( 4, this->_internal_notifytoken(), target); } // .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5; if (this->devicetype() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 5, this->_internal_devicetype(), target); } // string deviceAppVersion = 6; if (this->deviceappversion().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_deviceappversion().data(), static_cast(this->_internal_deviceappversion().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewSessionRequest.deviceAppVersion"); target = stream->WriteStringMaybeAliased( 6, this->_internal_deviceappversion(), target); } // string deviceOS = 7; if (this->deviceos().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_deviceos().data(), static_cast(this->_internal_deviceos().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewSessionRequest.deviceOS"); target = stream->WriteStringMaybeAliased( 7, this->_internal_deviceos(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.NewSessionRequest) return target; } size_t NewSessionRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.NewSessionRequest) 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 deviceID = 1; if (this->deviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_deviceid()); } // string publicKey = 2; if (this->publickey().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_publickey()); } // string signature = 3; if (this->signature().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_signature()); } // string notifyToken = 4; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_notifytoken()); } // string deviceAppVersion = 6; if (this->deviceappversion().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_deviceappversion()); } // string deviceOS = 7; if (this->deviceos().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_deviceos()); } // .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5; if (this->devicetype() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_devicetype()); } 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 NewSessionRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.NewSessionRequest) GOOGLE_DCHECK_NE(&from, this); const NewSessionRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.NewSessionRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.NewSessionRequest) MergeFrom(*source); } } void NewSessionRequest::MergeFrom(const NewSessionRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.NewSessionRequest) 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.deviceid().size() > 0) { _internal_set_deviceid(from._internal_deviceid()); } if (from.publickey().size() > 0) { _internal_set_publickey(from._internal_publickey()); } if (from.signature().size() > 0) { _internal_set_signature(from._internal_signature()); } if (from._internal_has_notifytoken()) { _internal_set_notifytoken(from._internal_notifytoken()); } if (from.deviceappversion().size() > 0) { _internal_set_deviceappversion(from._internal_deviceappversion()); } if (from.deviceos().size() > 0) { _internal_set_deviceos(from._internal_deviceos()); } if (from.devicetype() != 0) { _internal_set_devicetype(from._internal_devicetype()); } } void NewSessionRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.NewSessionRequest) if (&from == this) return; Clear(); MergeFrom(from); } void NewSessionRequest::CopyFrom(const NewSessionRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.NewSessionRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool NewSessionRequest::IsInitialized() const { return true; } void NewSessionRequest::InternalSwap(NewSessionRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); deviceid_.Swap(&other->deviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); publickey_.Swap(&other->publickey_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); signature_.Swap(&other->signature_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); notifytoken_.Swap(&other->notifytoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); deviceappversion_.Swap(&other->deviceappversion_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); deviceos_.Swap(&other->deviceos_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); swap(devicetype_, other->devicetype_); } ::PROTOBUF_NAMESPACE_ID::Metadata NewSessionRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class NewSessionResponse::_Internal { public: }; NewSessionResponse::NewSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.NewSessionResponse) } NewSessionResponse::NewSessionResponse(const NewSessionResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_sessionid().empty()) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sessionid(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.NewSessionResponse) } void NewSessionResponse::SharedCtor() { sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } NewSessionResponse::~NewSessionResponse() { // @@protoc_insertion_point(destructor:tunnelbroker.NewSessionResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void NewSessionResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); sessionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void NewSessionResponse::ArenaDtor(void* object) { NewSessionResponse* _this = reinterpret_cast< NewSessionResponse* >(object); (void)_this; } void NewSessionResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NewSessionResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } void NewSessionResponse::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.NewSessionResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; sessionid_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NewSessionResponse::_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 sessionID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_sessionid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewSessionResponse.sessionID")); 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* NewSessionResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.NewSessionResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string sessionID = 1; if (this->sessionid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_sessionid().data(), static_cast(this->_internal_sessionid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewSessionResponse.sessionID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_sessionid(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.NewSessionResponse) return target; } size_t NewSessionResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.NewSessionResponse) 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 sessionID = 1; if (this->sessionid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_sessionid()); } 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 NewSessionResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.NewSessionResponse) GOOGLE_DCHECK_NE(&from, this); const NewSessionResponse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.NewSessionResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.NewSessionResponse) MergeFrom(*source); } } void NewSessionResponse::MergeFrom(const NewSessionResponse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.NewSessionResponse) 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.sessionid().size() > 0) { _internal_set_sessionid(from._internal_sessionid()); } } void NewSessionResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.NewSessionResponse) if (&from == this) return; Clear(); MergeFrom(from); } void NewSessionResponse::CopyFrom(const NewSessionResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.NewSessionResponse) if (&from == this) return; Clear(); MergeFrom(from); } bool NewSessionResponse::IsInitialized() const { return true; } void NewSessionResponse::InternalSwap(NewSessionResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); sessionid_.Swap(&other->sessionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata NewSessionResponse::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class SendRequest::_Internal { public: }; SendRequest::SendRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), blobhashes_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.SendRequest) } SendRequest::SendRequest(const SendRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobhashes_(from.blobhashes_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_sessionid().empty()) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sessionid(), GetArena()); } todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_todeviceid().empty()) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(), GetArena()); } payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_payload().empty()) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.SendRequest) } void SendRequest::SharedCtor() { sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } SendRequest::~SendRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.SendRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void SendRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); sessionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SendRequest::ArenaDtor(void* object) { SendRequest* _this = reinterpret_cast< SendRequest* >(object); (void)_this; } void SendRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void SendRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void SendRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.SendRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobhashes_.Clear(); sessionid_.ClearToEmpty(); todeviceid_.ClearToEmpty(); payload_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* SendRequest::_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 sessionID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_sessionid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.SendRequest.sessionID")); CHK_(ptr); } else goto handle_unusual; continue; // string toDeviceID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_todeviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.SendRequest.toDeviceID")); CHK_(ptr); } else goto handle_unusual; continue; // bytes payload = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_payload(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated string blobHashes = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_blobhashes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.SendRequest.blobHashes")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { ctx->SetLastTag(tag); goto success; } ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); continue; } } // switch } // while success: return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* SendRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.SendRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string sessionID = 1; if (this->sessionid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_sessionid().data(), static_cast(this->_internal_sessionid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.SendRequest.sessionID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_sessionid(), target); } // string toDeviceID = 2; if (this->todeviceid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_todeviceid().data(), static_cast(this->_internal_todeviceid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.SendRequest.toDeviceID"); target = stream->WriteStringMaybeAliased( 2, this->_internal_todeviceid(), target); } // bytes payload = 3; if (this->payload().size() > 0) { target = stream->WriteBytesMaybeAliased( 3, this->_internal_payload(), target); } // repeated string blobHashes = 4; for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { const auto& s = this->_internal_blobhashes(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.SendRequest.blobHashes"); target = stream->WriteString(4, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.SendRequest) return target; } size_t SendRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.SendRequest) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string blobHashes = 4; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); for (int i = 0, n = blobhashes_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( blobhashes_.Get(i)); } // string sessionID = 1; if (this->sessionid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_sessionid()); } // string toDeviceID = 2; if (this->todeviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_todeviceid()); } // bytes payload = 3; if (this->payload().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_payload()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); SetCachedSize(cached_size); return total_size; } void SendRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.SendRequest) GOOGLE_DCHECK_NE(&from, this); const SendRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.SendRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.SendRequest) MergeFrom(*source); } } void SendRequest::MergeFrom(const SendRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.SendRequest) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; blobhashes_.MergeFrom(from.blobhashes_); if (from.sessionid().size() > 0) { _internal_set_sessionid(from._internal_sessionid()); } if (from.todeviceid().size() > 0) { _internal_set_todeviceid(from._internal_todeviceid()); } if (from.payload().size() > 0) { _internal_set_payload(from._internal_payload()); } } void SendRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.SendRequest) if (&from == this) return; Clear(); MergeFrom(from); } void SendRequest::CopyFrom(const SendRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.SendRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool SendRequest::IsInitialized() const { return true; } void SendRequest::InternalSwap(SendRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); blobhashes_.InternalSwap(&other->blobhashes_); sessionid_.Swap(&other->sessionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata SendRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class GetRequest::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_newnotifytoken(HasBits* has_bits) { (*has_bits)[0] |= 1u; } }; GetRequest::GetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.GetRequest) } GetRequest::GetRequest(const GetRequest& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_sessionid().empty()) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sessionid(), GetArena()); } newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (from._internal_has_newnotifytoken()) { newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_newnotifytoken(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.GetRequest) } void GetRequest::SharedCtor() { sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } GetRequest::~GetRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.GetRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void GetRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); sessionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); newnotifytoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void GetRequest::ArenaDtor(void* object) { GetRequest* _this = reinterpret_cast< GetRequest* >(object); (void)_this; } void GetRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void GetRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void GetRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.GetRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; sessionid_.ClearToEmpty(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { newnotifytoken_.ClearNonDefaultToEmpty(); } _has_bits_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* GetRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure _Internal::HasBits has_bits{}; while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { // string sessionID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_sessionid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.GetRequest.sessionID")); CHK_(ptr); } else goto handle_unusual; continue; // string newNotifyToken = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_newnotifytoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.GetRequest.newNotifyToken")); 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: _has_bits_.Or(has_bits); return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* GetRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.GetRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string sessionID = 1; if (this->sessionid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_sessionid().data(), static_cast(this->_internal_sessionid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.GetRequest.sessionID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_sessionid(), target); } // string newNotifyToken = 2; if (_internal_has_newnotifytoken()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_newnotifytoken().data(), static_cast(this->_internal_newnotifytoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.GetRequest.newNotifyToken"); target = stream->WriteStringMaybeAliased( 2, this->_internal_newnotifytoken(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.GetRequest) return target; } size_t GetRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.GetRequest) 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 sessionID = 1; if (this->sessionid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_sessionid()); } // string newNotifyToken = 2; cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x00000001u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_newnotifytoken()); } 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 GetRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.GetRequest) GOOGLE_DCHECK_NE(&from, this); const GetRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.GetRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.GetRequest) MergeFrom(*source); } } void GetRequest::MergeFrom(const GetRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.GetRequest) 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.sessionid().size() > 0) { _internal_set_sessionid(from._internal_sessionid()); } if (from._internal_has_newnotifytoken()) { _internal_set_newnotifytoken(from._internal_newnotifytoken()); } } void GetRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.GetRequest) if (&from == this) return; Clear(); MergeFrom(from); } void GetRequest::CopyFrom(const GetRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.GetRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool GetRequest::IsInitialized() const { return true; } void GetRequest::InternalSwap(GetRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); sessionid_.Swap(&other->sessionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); newnotifytoken_.Swap(&other->newnotifytoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata GetRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class GetResponseMessage::_Internal { public: }; GetResponseMessage::GetResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), blobhashes_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.GetResponseMessage) } GetResponseMessage::GetResponseMessage(const GetResponseMessage& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobhashes_(from.blobhashes_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_fromdeviceid().empty()) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(), GetArena()); } payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_payload().empty()) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.GetResponseMessage) } void GetResponseMessage::SharedCtor() { fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } GetResponseMessage::~GetResponseMessage() { // @@protoc_insertion_point(destructor:tunnelbroker.GetResponseMessage) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void GetResponseMessage::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void GetResponseMessage::ArenaDtor(void* object) { GetResponseMessage* _this = reinterpret_cast< GetResponseMessage* >(object); (void)_this; } void GetResponseMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void GetResponseMessage::SetCachedSize(int size) const { _cached_size_.Set(size); } void GetResponseMessage::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.GetResponseMessage) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobhashes_.Clear(); fromdeviceid_.ClearToEmpty(); payload_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* GetResponseMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { // string fromDeviceID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_fromdeviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.GetResponseMessage.fromDeviceID")); CHK_(ptr); } else goto handle_unusual; continue; // bytes payload = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_payload(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); } else goto handle_unusual; continue; // repeated string blobHashes = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_blobhashes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.GetResponseMessage.blobHashes")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { ctx->SetLastTag(tag); goto success; } ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); continue; } } // switch } // while success: return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* GetResponseMessage::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.GetResponseMessage) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string fromDeviceID = 1; if (this->fromdeviceid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_fromdeviceid().data(), static_cast(this->_internal_fromdeviceid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.GetResponseMessage.fromDeviceID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_fromdeviceid(), target); } // bytes payload = 2; if (this->payload().size() > 0) { target = stream->WriteBytesMaybeAliased( 2, this->_internal_payload(), target); } // repeated string blobHashes = 3; for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { const auto& s = this->_internal_blobhashes(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.GetResponseMessage.blobHashes"); target = stream->WriteString(3, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.GetResponseMessage) return target; } size_t GetResponseMessage::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.GetResponseMessage) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string blobHashes = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); for (int i = 0, n = blobhashes_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( blobhashes_.Get(i)); } // string fromDeviceID = 1; if (this->fromdeviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_fromdeviceid()); } // bytes payload = 2; if (this->payload().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_payload()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); SetCachedSize(cached_size); return total_size; } void GetResponseMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.GetResponseMessage) GOOGLE_DCHECK_NE(&from, this); const GetResponseMessage* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.GetResponseMessage) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.GetResponseMessage) MergeFrom(*source); } } void GetResponseMessage::MergeFrom(const GetResponseMessage& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.GetResponseMessage) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; blobhashes_.MergeFrom(from.blobhashes_); if (from.fromdeviceid().size() > 0) { _internal_set_fromdeviceid(from._internal_fromdeviceid()); } if (from.payload().size() > 0) { _internal_set_payload(from._internal_payload()); } } void GetResponseMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.GetResponseMessage) if (&from == this) return; Clear(); MergeFrom(from); } void GetResponseMessage::CopyFrom(const GetResponseMessage& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.GetResponseMessage) if (&from == this) return; Clear(); MergeFrom(from); } bool GetResponseMessage::IsInitialized() const { return true; } void GetResponseMessage::InternalSwap(GetResponseMessage* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); blobhashes_.InternalSwap(&other->blobhashes_); fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata GetResponseMessage::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class GetResponse::_Internal { public: static const ::tunnelbroker::GetResponseMessage& responsemessage(const GetResponse* msg); static const PROTOBUF_NAMESPACE_ID::Empty& ping(const GetResponse* msg); static const PROTOBUF_NAMESPACE_ID::Empty& newnotifytokenrequired(const GetResponse* msg); }; const ::tunnelbroker::GetResponseMessage& GetResponse::_Internal::responsemessage(const GetResponse* msg) { return *msg->data_.responsemessage_; } const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::_Internal::ping(const GetResponse* msg) { return *msg->data_.ping_; } const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::_Internal::newnotifytokenrequired(const GetResponse* msg) { return *msg->data_.newnotifytokenrequired_; } void GetResponse::set_allocated_responsemessage(::tunnelbroker::GetResponseMessage* responsemessage) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (responsemessage) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(responsemessage); if (message_arena != submessage_arena) { responsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, responsemessage, submessage_arena); } set_has_responsemessage(); data_.responsemessage_ = responsemessage; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.responseMessage) } void GetResponse::set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (ping) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ping)->GetArena(); if (message_arena != submessage_arena) { ping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, ping, submessage_arena); } set_has_ping(); data_.ping_ = ping; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.ping) } void GetResponse::clear_ping() { if (_internal_has_ping()) { if (GetArena() == nullptr) { delete data_.ping_; } clear_has_data(); } } void GetResponse::set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (newnotifytokenrequired) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(newnotifytokenrequired)->GetArena(); if (message_arena != submessage_arena) { newnotifytokenrequired = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, newnotifytokenrequired, submessage_arena); } set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = newnotifytokenrequired; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponse.newNotifyTokenRequired) } void GetResponse::clear_newnotifytokenrequired() { if (_internal_has_newnotifytokenrequired()) { if (GetArena() == nullptr) { delete data_.newnotifytokenrequired_; } clear_has_data(); } } GetResponse::GetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.GetResponse) } GetResponse::GetResponse(const GetResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); clear_has_data(); switch (from.data_case()) { case kResponseMessage: { _internal_mutable_responsemessage()->::tunnelbroker::GetResponseMessage::MergeFrom(from._internal_responsemessage()); break; } case kPing: { _internal_mutable_ping()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_ping()); break; } case kNewNotifyTokenRequired: { _internal_mutable_newnotifytokenrequired()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_newnotifytokenrequired()); break; } case DATA_NOT_SET: { break; } } // @@protoc_insertion_point(copy_constructor:tunnelbroker.GetResponse) } void GetResponse::SharedCtor() { clear_has_data(); } GetResponse::~GetResponse() { // @@protoc_insertion_point(destructor:tunnelbroker.GetResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void GetResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (has_data()) { clear_data(); } } void GetResponse::ArenaDtor(void* object) { GetResponse* _this = reinterpret_cast< GetResponse* >(object); (void)_this; } void GetResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void GetResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } void GetResponse::clear_data() { // @@protoc_insertion_point(one_of_clear_start:tunnelbroker.GetResponse) switch (data_case()) { case kResponseMessage: { if (GetArena() == nullptr) { delete data_.responsemessage_; } break; } case kPing: { if (GetArena() == nullptr) { delete data_.ping_; } break; } case kNewNotifyTokenRequired: { if (GetArena() == nullptr) { delete data_.newnotifytokenrequired_; } break; } case DATA_NOT_SET: { break; } } _oneof_case_[0] = DATA_NOT_SET; } void GetResponse::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.GetResponse) ::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* GetResponse::_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) { // .tunnelbroker.GetResponseMessage responseMessage = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_responsemessage(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // .google.protobuf.Empty ping = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_ping(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // .google.protobuf.Empty newNotifyTokenRequired = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_newnotifytokenrequired(), 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* GetResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.GetResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // .tunnelbroker.GetResponseMessage responseMessage = 1; if (_internal_has_responsemessage()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::responsemessage(this), target, stream); } // .google.protobuf.Empty ping = 2; if (_internal_has_ping()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 2, _Internal::ping(this), target, stream); } // .google.protobuf.Empty newNotifyTokenRequired = 3; if (_internal_has_newnotifytokenrequired()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::newnotifytokenrequired(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:tunnelbroker.GetResponse) return target; } size_t GetResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.GetResponse) 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()) { // .tunnelbroker.GetResponseMessage responseMessage = 1; case kResponseMessage: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.responsemessage_); break; } // .google.protobuf.Empty ping = 2; case kPing: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.ping_); break; } // .google.protobuf.Empty newNotifyTokenRequired = 3; case kNewNotifyTokenRequired: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.newnotifytokenrequired_); 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 GetResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.GetResponse) GOOGLE_DCHECK_NE(&from, this); const GetResponse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.GetResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.GetResponse) MergeFrom(*source); } } void GetResponse::MergeFrom(const GetResponse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.GetResponse) 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 kResponseMessage: { _internal_mutable_responsemessage()->::tunnelbroker::GetResponseMessage::MergeFrom(from._internal_responsemessage()); break; } case kPing: { _internal_mutable_ping()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_ping()); break; } case kNewNotifyTokenRequired: { _internal_mutable_newnotifytokenrequired()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_newnotifytokenrequired()); break; } case DATA_NOT_SET: { break; } } } void GetResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.GetResponse) if (&from == this) return; Clear(); MergeFrom(from); } void GetResponse::CopyFrom(const GetResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.GetResponse) if (&from == this) return; Clear(); MergeFrom(from); } bool GetResponse::IsInitialized() const { return true; } void GetResponse::InternalSwap(GetResponse* 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 GetResponse::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class ProcessedMessages::_Internal { public: }; ProcessedMessages::ProcessedMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), messageid_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.ProcessedMessages) } ProcessedMessages::ProcessedMessages(const ProcessedMessages& from) : ::PROTOBUF_NAMESPACE_ID::Message(), messageid_(from.messageid_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:tunnelbroker.ProcessedMessages) } void ProcessedMessages::SharedCtor() { } ProcessedMessages::~ProcessedMessages() { // @@protoc_insertion_point(destructor:tunnelbroker.ProcessedMessages) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void ProcessedMessages::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } void ProcessedMessages::ArenaDtor(void* object) { ProcessedMessages* _this = reinterpret_cast< ProcessedMessages* >(object); (void)_this; } void ProcessedMessages::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void ProcessedMessages::SetCachedSize(int size) const { _cached_size_.Set(size); } void ProcessedMessages::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; messageid_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ProcessedMessages::_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) { // repeated string messageID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_messageid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.ProcessedMessages.messageID")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* ProcessedMessages::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // repeated string messageID = 1; for (int i = 0, n = this->_internal_messageid_size(); i < n; i++) { const auto& s = this->_internal_messageid(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.ProcessedMessages.messageID"); target = stream->WriteString(1, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.ProcessedMessages) return target; } size_t ProcessedMessages::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.ProcessedMessages) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string messageID = 1; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(messageid_.size()); for (int i = 0, n = messageid_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( messageid_.Get(i)); } 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 ProcessedMessages::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.ProcessedMessages) GOOGLE_DCHECK_NE(&from, this); const ProcessedMessages* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.ProcessedMessages) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.ProcessedMessages) MergeFrom(*source); } } void ProcessedMessages::MergeFrom(const ProcessedMessages& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.ProcessedMessages) 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; messageid_.MergeFrom(from.messageid_); } void ProcessedMessages::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.ProcessedMessages) if (&from == this) return; Clear(); MergeFrom(from); } void ProcessedMessages::CopyFrom(const ProcessedMessages& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.ProcessedMessages) if (&from == this) return; Clear(); MergeFrom(from); } bool ProcessedMessages::IsInitialized() const { return true; } void ProcessedMessages::InternalSwap(ProcessedMessages* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); messageid_.InternalSwap(&other->messageid_); } ::PROTOBUF_NAMESPACE_ID::Metadata ProcessedMessages::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessageToTunnelbrokerStruct::_Internal { public: }; MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), blobhashes_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToTunnelbrokerStruct) } MessageToTunnelbrokerStruct::MessageToTunnelbrokerStruct(const MessageToTunnelbrokerStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobhashes_(from.blobhashes_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_messageid().empty()) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_messageid(), GetArena()); } todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_todeviceid().empty()) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_todeviceid(), GetArena()); } payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_payload().empty()) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToTunnelbrokerStruct) } void MessageToTunnelbrokerStruct::SharedCtor() { messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); todeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } MessageToTunnelbrokerStruct::~MessageToTunnelbrokerStruct() { // @@protoc_insertion_point(destructor:tunnelbroker.MessageToTunnelbrokerStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessageToTunnelbrokerStruct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); messageid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); todeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void MessageToTunnelbrokerStruct::ArenaDtor(void* object) { MessageToTunnelbrokerStruct* _this = reinterpret_cast< MessageToTunnelbrokerStruct* >(object); (void)_this; } void MessageToTunnelbrokerStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessageToTunnelbrokerStruct::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessageToTunnelbrokerStruct::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobhashes_.Clear(); messageid_.ClearToEmpty(); todeviceid_.ClearToEmpty(); payload_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MessageToTunnelbrokerStruct::_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 messageID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_messageid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.messageID")); CHK_(ptr); } else goto handle_unusual; continue; // string toDeviceID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_todeviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID")); CHK_(ptr); } else goto handle_unusual; continue; // string payload = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_payload(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.payload")); CHK_(ptr); } else goto handle_unusual; continue; // repeated string blobHashes = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_blobhashes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbrokerStruct.blobHashes")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { ctx->SetLastTag(tag); goto success; } ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); continue; } } // switch } // while success: return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* MessageToTunnelbrokerStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string messageID = 1; if (this->messageid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_messageid().data(), static_cast(this->_internal_messageid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToTunnelbrokerStruct.messageID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_messageid(), target); } // string toDeviceID = 2; if (this->todeviceid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_todeviceid().data(), static_cast(this->_internal_todeviceid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID"); target = stream->WriteStringMaybeAliased( 2, this->_internal_todeviceid(), target); } // string payload = 3; if (this->payload().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_payload().data(), static_cast(this->_internal_payload().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToTunnelbrokerStruct.payload"); target = stream->WriteStringMaybeAliased( 3, this->_internal_payload(), target); } // repeated string blobHashes = 4; for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { const auto& s = this->_internal_blobhashes(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToTunnelbrokerStruct.blobHashes"); target = stream->WriteString(4, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToTunnelbrokerStruct) return target; } size_t MessageToTunnelbrokerStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToTunnelbrokerStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string blobHashes = 4; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); for (int i = 0, n = blobhashes_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( blobhashes_.Get(i)); } // string messageID = 1; if (this->messageid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_messageid()); } // string toDeviceID = 2; if (this->todeviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_todeviceid()); } // string payload = 3; if (this->payload().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_payload()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); SetCachedSize(cached_size); return total_size; } void MessageToTunnelbrokerStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToTunnelbrokerStruct) GOOGLE_DCHECK_NE(&from, this); const MessageToTunnelbrokerStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToTunnelbrokerStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToTunnelbrokerStruct) MergeFrom(*source); } } void MessageToTunnelbrokerStruct::MergeFrom(const MessageToTunnelbrokerStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToTunnelbrokerStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; blobhashes_.MergeFrom(from.blobhashes_); if (from.messageid().size() > 0) { _internal_set_messageid(from._internal_messageid()); } if (from.todeviceid().size() > 0) { _internal_set_todeviceid(from._internal_todeviceid()); } if (from.payload().size() > 0) { _internal_set_payload(from._internal_payload()); } } void MessageToTunnelbrokerStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToTunnelbrokerStruct) if (&from == this) return; Clear(); MergeFrom(from); } void MessageToTunnelbrokerStruct::CopyFrom(const MessageToTunnelbrokerStruct& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToTunnelbrokerStruct) if (&from == this) return; Clear(); MergeFrom(from); } bool MessageToTunnelbrokerStruct::IsInitialized() const { return true; } void MessageToTunnelbrokerStruct::InternalSwap(MessageToTunnelbrokerStruct* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); blobhashes_.InternalSwap(&other->blobhashes_); messageid_.Swap(&other->messageid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); todeviceid_.Swap(&other->todeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata MessageToTunnelbrokerStruct::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessagesToSend::_Internal { public: }; MessagesToSend::MessagesToSend(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), messages_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessagesToSend) } MessagesToSend::MessagesToSend(const MessagesToSend& from) : ::PROTOBUF_NAMESPACE_ID::Message(), messages_(from.messages_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessagesToSend) } void MessagesToSend::SharedCtor() { } MessagesToSend::~MessagesToSend() { // @@protoc_insertion_point(destructor:tunnelbroker.MessagesToSend) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessagesToSend::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } void MessagesToSend::ArenaDtor(void* object) { MessagesToSend* _this = reinterpret_cast< MessagesToSend* >(object); (void)_this; } void MessagesToSend::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessagesToSend::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessagesToSend::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessagesToSend) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; messages_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MessagesToSend::_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) { // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_messages(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* MessagesToSend::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessagesToSend) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; for (unsigned int i = 0, n = static_cast(this->_internal_messages_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, this->_internal_messages(i), 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:tunnelbroker.MessagesToSend) return target; } size_t MessagesToSend::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessagesToSend) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; total_size += 1UL * this->_internal_messages_size(); for (const auto& msg : this->messages_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } 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 MessagesToSend::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessagesToSend) GOOGLE_DCHECK_NE(&from, this); const MessagesToSend* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessagesToSend) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessagesToSend) MergeFrom(*source); } } void MessagesToSend::MergeFrom(const MessagesToSend& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessagesToSend) 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; messages_.MergeFrom(from.messages_); } void MessagesToSend::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessagesToSend) if (&from == this) return; Clear(); MergeFrom(from); } void MessagesToSend::CopyFrom(const MessagesToSend& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessagesToSend) if (&from == this) return; Clear(); MergeFrom(from); } bool MessagesToSend::IsInitialized() const { return true; } void MessagesToSend::InternalSwap(MessagesToSend* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); messages_.InternalSwap(&other->messages_); } ::PROTOBUF_NAMESPACE_ID::Metadata MessagesToSend::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessageToTunnelbroker::_Internal { public: static const ::tunnelbroker::MessagesToSend& messagestosend(const MessageToTunnelbroker* msg); static const ::tunnelbroker::ProcessedMessages& processedmessages(const MessageToTunnelbroker* msg); }; const ::tunnelbroker::MessagesToSend& MessageToTunnelbroker::_Internal::messagestosend(const MessageToTunnelbroker* msg) { return *msg->data_.messagestosend_; } const ::tunnelbroker::ProcessedMessages& MessageToTunnelbroker::_Internal::processedmessages(const MessageToTunnelbroker* msg) { return *msg->data_.processedmessages_; } void MessageToTunnelbroker::set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (messagestosend) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(messagestosend); if (message_arena != submessage_arena) { messagestosend = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, messagestosend, submessage_arena); } set_has_messagestosend(); data_.messagestosend_ = messagestosend; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.messagesToSend) } void MessageToTunnelbroker::set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (processedmessages) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(processedmessages); if (message_arena != submessage_arena) { processedmessages = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, processedmessages, submessage_arena); } set_has_processedmessages(); data_.processedmessages_ = processedmessages; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.processedMessages) } MessageToTunnelbroker::MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToTunnelbroker) } MessageToTunnelbroker::MessageToTunnelbroker(const MessageToTunnelbroker& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_sessionid().empty()) { - sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_sessionid(), - GetArena()); - } clear_has_data(); switch (from.data_case()) { case kMessagesToSend: { _internal_mutable_messagestosend()->::tunnelbroker::MessagesToSend::MergeFrom(from._internal_messagestosend()); break; } case kProcessedMessages: { _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); break; } case kNewNotifyToken: { _internal_set_newnotifytoken(from._internal_newnotifytoken()); break; } case DATA_NOT_SET: { break; } } // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToTunnelbroker) } void MessageToTunnelbroker::SharedCtor() { -sessionid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); clear_has_data(); } MessageToTunnelbroker::~MessageToTunnelbroker() { // @@protoc_insertion_point(destructor:tunnelbroker.MessageToTunnelbroker) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessageToTunnelbroker::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - sessionid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (has_data()) { clear_data(); } } void MessageToTunnelbroker::ArenaDtor(void* object) { MessageToTunnelbroker* _this = reinterpret_cast< MessageToTunnelbroker* >(object); (void)_this; } void MessageToTunnelbroker::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessageToTunnelbroker::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessageToTunnelbroker::clear_data() { // @@protoc_insertion_point(one_of_clear_start:tunnelbroker.MessageToTunnelbroker) switch (data_case()) { case kMessagesToSend: { if (GetArena() == nullptr) { delete data_.messagestosend_; } break; } case kProcessedMessages: { if (GetArena() == nullptr) { delete data_.processedmessages_; } break; } case kNewNotifyToken: { data_.newnotifytoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case DATA_NOT_SET: { break; } } _oneof_case_[0] = DATA_NOT_SET; } void MessageToTunnelbroker::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToTunnelbroker) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - sessionid_.ClearToEmpty(); clear_data(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MessageToTunnelbroker::_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 sessionID = 1; + // .tunnelbroker.MessagesToSend messagesToSend = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_sessionid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbroker.sessionID")); + ptr = ctx->ParseMessage(_internal_mutable_messagestosend(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .tunnelbroker.MessagesToSend messagesToSend = 2; + // .tunnelbroker.ProcessedMessages processedMessages = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_messagestosend(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_processedmessages(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .tunnelbroker.ProcessedMessages processedMessages = 3; + // string newNotifyToken = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_processedmessages(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string newNotifyToken = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { auto str = _internal_mutable_newnotifytoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToTunnelbroker.newNotifyToken")); 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* MessageToTunnelbroker::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToTunnelbroker) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string sessionID = 1; - if (this->sessionid().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_sessionid().data(), static_cast(this->_internal_sessionid().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "tunnelbroker.MessageToTunnelbroker.sessionID"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_sessionid(), target); - } - - // .tunnelbroker.MessagesToSend messagesToSend = 2; + // .tunnelbroker.MessagesToSend messagesToSend = 1; if (_internal_has_messagestosend()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::messagestosend(this), target, stream); + 1, _Internal::messagestosend(this), target, stream); } - // .tunnelbroker.ProcessedMessages processedMessages = 3; + // .tunnelbroker.ProcessedMessages processedMessages = 2; if (_internal_has_processedmessages()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 3, _Internal::processedmessages(this), target, stream); + 2, _Internal::processedmessages(this), target, stream); } - // string newNotifyToken = 4; + // string newNotifyToken = 3; if (_internal_has_newnotifytoken()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_newnotifytoken().data(), static_cast(this->_internal_newnotifytoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToTunnelbroker.newNotifyToken"); target = stream->WriteStringMaybeAliased( - 4, this->_internal_newnotifytoken(), target); + 3, this->_internal_newnotifytoken(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToTunnelbroker) return target; } size_t MessageToTunnelbroker::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToTunnelbroker) 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 sessionID = 1; - if (this->sessionid().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_sessionid()); - } - switch (data_case()) { - // .tunnelbroker.MessagesToSend messagesToSend = 2; + // .tunnelbroker.MessagesToSend messagesToSend = 1; case kMessagesToSend: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.messagestosend_); break; } - // .tunnelbroker.ProcessedMessages processedMessages = 3; + // .tunnelbroker.ProcessedMessages processedMessages = 2; case kProcessedMessages: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.processedmessages_); break; } - // string newNotifyToken = 4; + // string newNotifyToken = 3; case kNewNotifyToken: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_newnotifytoken()); 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 MessageToTunnelbroker::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToTunnelbroker) GOOGLE_DCHECK_NE(&from, this); const MessageToTunnelbroker* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToTunnelbroker) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToTunnelbroker) MergeFrom(*source); } } void MessageToTunnelbroker::MergeFrom(const MessageToTunnelbroker& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToTunnelbroker) 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.sessionid().size() > 0) { - _internal_set_sessionid(from._internal_sessionid()); - } switch (from.data_case()) { case kMessagesToSend: { _internal_mutable_messagestosend()->::tunnelbroker::MessagesToSend::MergeFrom(from._internal_messagestosend()); break; } case kProcessedMessages: { _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); break; } case kNewNotifyToken: { _internal_set_newnotifytoken(from._internal_newnotifytoken()); break; } case DATA_NOT_SET: { break; } } } void MessageToTunnelbroker::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToTunnelbroker) if (&from == this) return; Clear(); MergeFrom(from); } void MessageToTunnelbroker::CopyFrom(const MessageToTunnelbroker& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToTunnelbroker) if (&from == this) return; Clear(); MergeFrom(from); } bool MessageToTunnelbroker::IsInitialized() const { return true; } void MessageToTunnelbroker::InternalSwap(MessageToTunnelbroker* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - sessionid_.Swap(&other->sessionid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); swap(data_, other->data_); swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata MessageToTunnelbroker::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessageToClientStruct::_Internal { public: }; MessageToClientStruct::MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), blobhashes_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToClientStruct) } MessageToClientStruct::MessageToClientStruct(const MessageToClientStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), blobhashes_(from.blobhashes_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_messageid().empty()) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_messageid(), GetArena()); } fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_fromdeviceid().empty()) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_fromdeviceid(), GetArena()); } payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_payload().empty()) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_payload(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToClientStruct) } void MessageToClientStruct::SharedCtor() { messageid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); fromdeviceid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } MessageToClientStruct::~MessageToClientStruct() { // @@protoc_insertion_point(destructor:tunnelbroker.MessageToClientStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessageToClientStruct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); messageid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); fromdeviceid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); payload_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void MessageToClientStruct::ArenaDtor(void* object) { MessageToClientStruct* _this = reinterpret_cast< MessageToClientStruct* >(object); (void)_this; } void MessageToClientStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessageToClientStruct::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessageToClientStruct::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToClientStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; blobhashes_.Clear(); messageid_.ClearToEmpty(); fromdeviceid_.ClearToEmpty(); payload_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MessageToClientStruct::_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 messageID = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_messageid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.messageID")); CHK_(ptr); } else goto handle_unusual; continue; // string fromDeviceID = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_fromdeviceid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.fromDeviceID")); CHK_(ptr); } else goto handle_unusual; continue; // string payload = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_payload(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.payload")); CHK_(ptr); } else goto handle_unusual; continue; // repeated string blobHashes = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr -= 1; do { ptr += 1; auto str = _internal_add_blobhashes(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.MessageToClientStruct.blobHashes")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { ctx->SetLastTag(tag); goto success; } ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); continue; } } // switch } // while success: return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* MessageToClientStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToClientStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // string messageID = 1; if (this->messageid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_messageid().data(), static_cast(this->_internal_messageid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToClientStruct.messageID"); target = stream->WriteStringMaybeAliased( 1, this->_internal_messageid(), target); } // string fromDeviceID = 2; if (this->fromdeviceid().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_fromdeviceid().data(), static_cast(this->_internal_fromdeviceid().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToClientStruct.fromDeviceID"); target = stream->WriteStringMaybeAliased( 2, this->_internal_fromdeviceid(), target); } // string payload = 3; if (this->payload().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_payload().data(), static_cast(this->_internal_payload().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToClientStruct.payload"); target = stream->WriteStringMaybeAliased( 3, this->_internal_payload(), target); } // repeated string blobHashes = 4; for (int i = 0, n = this->_internal_blobhashes_size(); i < n; i++) { const auto& s = this->_internal_blobhashes(i); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.MessageToClientStruct.blobHashes"); target = stream->WriteString(4, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.MessageToClientStruct) return target; } size_t MessageToClientStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToClientStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated string blobHashes = 4; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(blobhashes_.size()); for (int i = 0, n = blobhashes_.size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( blobhashes_.Get(i)); } // string messageID = 1; if (this->messageid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_messageid()); } // string fromDeviceID = 2; if (this->fromdeviceid().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_fromdeviceid()); } // string payload = 3; if (this->payload().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_payload()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); SetCachedSize(cached_size); return total_size; } void MessageToClientStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToClientStruct) GOOGLE_DCHECK_NE(&from, this); const MessageToClientStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToClientStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToClientStruct) MergeFrom(*source); } } void MessageToClientStruct::MergeFrom(const MessageToClientStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToClientStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; blobhashes_.MergeFrom(from.blobhashes_); if (from.messageid().size() > 0) { _internal_set_messageid(from._internal_messageid()); } if (from.fromdeviceid().size() > 0) { _internal_set_fromdeviceid(from._internal_fromdeviceid()); } if (from.payload().size() > 0) { _internal_set_payload(from._internal_payload()); } } void MessageToClientStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToClientStruct) if (&from == this) return; Clear(); MergeFrom(from); } void MessageToClientStruct::CopyFrom(const MessageToClientStruct& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToClientStruct) if (&from == this) return; Clear(); MergeFrom(from); } bool MessageToClientStruct::IsInitialized() const { return true; } void MessageToClientStruct::InternalSwap(MessageToClientStruct* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); blobhashes_.InternalSwap(&other->blobhashes_); messageid_.Swap(&other->messageid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); fromdeviceid_.Swap(&other->fromdeviceid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata MessageToClientStruct::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessagesToDeliver::_Internal { public: }; MessagesToDeliver::MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), messages_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessagesToDeliver) } MessagesToDeliver::MessagesToDeliver(const MessagesToDeliver& from) : ::PROTOBUF_NAMESPACE_ID::Message(), messages_(from.messages_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessagesToDeliver) } void MessagesToDeliver::SharedCtor() { } MessagesToDeliver::~MessagesToDeliver() { // @@protoc_insertion_point(destructor:tunnelbroker.MessagesToDeliver) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessagesToDeliver::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } void MessagesToDeliver::ArenaDtor(void* object) { MessagesToDeliver* _this = reinterpret_cast< MessagesToDeliver* >(object); (void)_this; } void MessagesToDeliver::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessagesToDeliver::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessagesToDeliver::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessagesToDeliver) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; messages_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* MessagesToDeliver::_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) { // repeated .tunnelbroker.MessageToClientStruct messages = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; ptr = ctx->ParseMessage(_internal_add_messages(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* MessagesToDeliver::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessagesToDeliver) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // repeated .tunnelbroker.MessageToClientStruct messages = 1; for (unsigned int i = 0, n = static_cast(this->_internal_messages_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage(1, this->_internal_messages(i), 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:tunnelbroker.MessagesToDeliver) return target; } size_t MessagesToDeliver::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessagesToDeliver) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // repeated .tunnelbroker.MessageToClientStruct messages = 1; total_size += 1UL * this->_internal_messages_size(); for (const auto& msg : this->messages_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } 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 MessagesToDeliver::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessagesToDeliver) GOOGLE_DCHECK_NE(&from, this); const MessagesToDeliver* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessagesToDeliver) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessagesToDeliver) MergeFrom(*source); } } void MessagesToDeliver::MergeFrom(const MessagesToDeliver& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessagesToDeliver) 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; messages_.MergeFrom(from.messages_); } void MessagesToDeliver::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessagesToDeliver) if (&from == this) return; Clear(); MergeFrom(from); } void MessagesToDeliver::CopyFrom(const MessagesToDeliver& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessagesToDeliver) if (&from == this) return; Clear(); MergeFrom(from); } bool MessagesToDeliver::IsInitialized() const { return true; } void MessagesToDeliver::InternalSwap(MessagesToDeliver* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); messages_.InternalSwap(&other->messages_); } ::PROTOBUF_NAMESPACE_ID::Metadata MessagesToDeliver::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class MessageToClient::_Internal { public: static const ::tunnelbroker::MessagesToDeliver& messagestodeliver(const MessageToClient* msg); static const ::tunnelbroker::ProcessedMessages& processedmessages(const MessageToClient* msg); static const PROTOBUF_NAMESPACE_ID::Empty& newnotifytokenrequired(const MessageToClient* msg); static const PROTOBUF_NAMESPACE_ID::Empty& ping(const MessageToClient* msg); }; const ::tunnelbroker::MessagesToDeliver& MessageToClient::_Internal::messagestodeliver(const MessageToClient* msg) { return *msg->data_.messagestodeliver_; } const ::tunnelbroker::ProcessedMessages& MessageToClient::_Internal::processedmessages(const MessageToClient* msg) { return *msg->data_.processedmessages_; } const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::_Internal::newnotifytokenrequired(const MessageToClient* msg) { return *msg->data_.newnotifytokenrequired_; } const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::_Internal::ping(const MessageToClient* msg) { return *msg->data_.ping_; } void MessageToClient::set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (messagestodeliver) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(messagestodeliver); if (message_arena != submessage_arena) { messagestodeliver = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, messagestodeliver, submessage_arena); } set_has_messagestodeliver(); data_.messagestodeliver_ = messagestodeliver; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.messagesToDeliver) } void MessageToClient::set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (processedmessages) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(processedmessages); if (message_arena != submessage_arena) { processedmessages = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, processedmessages, submessage_arena); } set_has_processedmessages(); data_.processedmessages_ = processedmessages; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.processedMessages) } void MessageToClient::set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (newnotifytokenrequired) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(newnotifytokenrequired)->GetArena(); if (message_arena != submessage_arena) { newnotifytokenrequired = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, newnotifytokenrequired, submessage_arena); } set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = newnotifytokenrequired; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.newNotifyTokenRequired) } void MessageToClient::clear_newnotifytokenrequired() { if (_internal_has_newnotifytokenrequired()) { if (GetArena() == nullptr) { delete data_.newnotifytokenrequired_; } clear_has_data(); } } void MessageToClient::set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_data(); if (ping) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ping)->GetArena(); if (message_arena != submessage_arena) { ping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, ping, submessage_arena); } set_has_ping(); data_.ping_ = ping; } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClient.ping) } void MessageToClient::clear_ping() { if (_internal_has_ping()) { if (GetArena() == nullptr) { delete data_.ping_; } clear_has_data(); } } MessageToClient::MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.MessageToClient) } MessageToClient::MessageToClient(const MessageToClient& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); clear_has_data(); switch (from.data_case()) { case kMessagesToDeliver: { _internal_mutable_messagestodeliver()->::tunnelbroker::MessagesToDeliver::MergeFrom(from._internal_messagestodeliver()); break; } case kProcessedMessages: { _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); break; } case kNewNotifyTokenRequired: { _internal_mutable_newnotifytokenrequired()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_newnotifytokenrequired()); break; } case kPing: { _internal_mutable_ping()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_ping()); break; } case DATA_NOT_SET: { break; } } // @@protoc_insertion_point(copy_constructor:tunnelbroker.MessageToClient) } void MessageToClient::SharedCtor() { clear_has_data(); } MessageToClient::~MessageToClient() { // @@protoc_insertion_point(destructor:tunnelbroker.MessageToClient) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void MessageToClient::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (has_data()) { clear_data(); } } void MessageToClient::ArenaDtor(void* object) { MessageToClient* _this = reinterpret_cast< MessageToClient* >(object); (void)_this; } void MessageToClient::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void MessageToClient::SetCachedSize(int size) const { _cached_size_.Set(size); } void MessageToClient::clear_data() { // @@protoc_insertion_point(one_of_clear_start:tunnelbroker.MessageToClient) switch (data_case()) { case kMessagesToDeliver: { if (GetArena() == nullptr) { delete data_.messagestodeliver_; } break; } case kProcessedMessages: { if (GetArena() == nullptr) { delete data_.processedmessages_; } break; } case kNewNotifyTokenRequired: { if (GetArena() == nullptr) { delete data_.newnotifytokenrequired_; } break; } case kPing: { if (GetArena() == nullptr) { delete data_.ping_; } break; } case DATA_NOT_SET: { break; } } _oneof_case_[0] = DATA_NOT_SET; } void MessageToClient::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.MessageToClient) ::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* MessageToClient::_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) { // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_messagestodeliver(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // .tunnelbroker.ProcessedMessages processedMessages = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_processedmessages(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // .google.protobuf.Empty newNotifyTokenRequired = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_newnotifytokenrequired(), ptr); CHK_(ptr); } else goto handle_unusual; continue; // .google.protobuf.Empty ping = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_ping(), 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* MessageToClient::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.MessageToClient) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; if (_internal_has_messagestodeliver()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 1, _Internal::messagestodeliver(this), target, stream); } // .tunnelbroker.ProcessedMessages processedMessages = 2; if (_internal_has_processedmessages()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 2, _Internal::processedmessages(this), target, stream); } // .google.protobuf.Empty newNotifyTokenRequired = 3; if (_internal_has_newnotifytokenrequired()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 3, _Internal::newnotifytokenrequired(this), target, stream); } // .google.protobuf.Empty ping = 4; if (_internal_has_ping()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( 4, _Internal::ping(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:tunnelbroker.MessageToClient) return target; } size_t MessageToClient::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.MessageToClient) 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()) { // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; case kMessagesToDeliver: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.messagestodeliver_); break; } // .tunnelbroker.ProcessedMessages processedMessages = 2; case kProcessedMessages: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.processedmessages_); break; } // .google.protobuf.Empty newNotifyTokenRequired = 3; case kNewNotifyTokenRequired: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.newnotifytokenrequired_); break; } // .google.protobuf.Empty ping = 4; case kPing: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *data_.ping_); 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 MessageToClient::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.MessageToClient) GOOGLE_DCHECK_NE(&from, this); const MessageToClient* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.MessageToClient) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.MessageToClient) MergeFrom(*source); } } void MessageToClient::MergeFrom(const MessageToClient& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.MessageToClient) 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 kMessagesToDeliver: { _internal_mutable_messagestodeliver()->::tunnelbroker::MessagesToDeliver::MergeFrom(from._internal_messagestodeliver()); break; } case kProcessedMessages: { _internal_mutable_processedmessages()->::tunnelbroker::ProcessedMessages::MergeFrom(from._internal_processedmessages()); break; } case kNewNotifyTokenRequired: { _internal_mutable_newnotifytokenrequired()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_newnotifytokenrequired()); break; } case kPing: { _internal_mutable_ping()->PROTOBUF_NAMESPACE_ID::Empty::MergeFrom(from._internal_ping()); break; } case DATA_NOT_SET: { break; } } } void MessageToClient::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.MessageToClient) if (&from == this) return; Clear(); MergeFrom(from); } void MessageToClient::CopyFrom(const MessageToClient& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.MessageToClient) if (&from == this) return; Clear(); MergeFrom(from); } bool MessageToClient::IsInitialized() const { return true; } void MessageToClient::InternalSwap(MessageToClient* 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 MessageToClient::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class CheckRequest::_Internal { public: }; CheckRequest::CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.CheckRequest) } CheckRequest::CheckRequest(const CheckRequest& 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()); } devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_devicetoken().empty()) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_devicetoken(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.CheckRequest) } void CheckRequest::SharedCtor() { userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } CheckRequest::~CheckRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.CheckRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void CheckRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void CheckRequest::ArenaDtor(void* object) { CheckRequest* _this = reinterpret_cast< CheckRequest* >(object); (void)_this; } void CheckRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void CheckRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void CheckRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.CheckRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; userid_.ClearToEmpty(); devicetoken_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* CheckRequest::_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, "tunnelbroker.CheckRequest.userId")); CHK_(ptr); } else goto handle_unusual; continue; // string deviceToken = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_devicetoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.CheckRequest.deviceToken")); 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* CheckRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.CheckRequest) ::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, "tunnelbroker.CheckRequest.userId"); target = stream->WriteStringMaybeAliased( 1, this->_internal_userid(), target); } // string deviceToken = 2; if (this->devicetoken().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_devicetoken().data(), static_cast(this->_internal_devicetoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.CheckRequest.deviceToken"); target = stream->WriteStringMaybeAliased( 2, this->_internal_devicetoken(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.CheckRequest) return target; } size_t CheckRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.CheckRequest) 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 deviceToken = 2; if (this->devicetoken().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_devicetoken()); } 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 CheckRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.CheckRequest) GOOGLE_DCHECK_NE(&from, this); const CheckRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.CheckRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.CheckRequest) MergeFrom(*source); } } void CheckRequest::MergeFrom(const CheckRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.CheckRequest) 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.devicetoken().size() > 0) { _internal_set_devicetoken(from._internal_devicetoken()); } } void CheckRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.CheckRequest) if (&from == this) return; Clear(); MergeFrom(from); } void CheckRequest::CopyFrom(const CheckRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.CheckRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool CheckRequest::IsInitialized() const { return true; } void CheckRequest::InternalSwap(CheckRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); devicetoken_.Swap(&other->devicetoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata CheckRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class CheckResponse::_Internal { public: }; CheckResponse::CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.CheckResponse) } CheckResponse::CheckResponse(const CheckResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); checkresponsetype_ = from.checkresponsetype_; // @@protoc_insertion_point(copy_constructor:tunnelbroker.CheckResponse) } void CheckResponse::SharedCtor() { checkresponsetype_ = 0; } CheckResponse::~CheckResponse() { // @@protoc_insertion_point(destructor:tunnelbroker.CheckResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void CheckResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } void CheckResponse::ArenaDtor(void* object) { CheckResponse* _this = reinterpret_cast< CheckResponse* >(object); (void)_this; } void CheckResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void CheckResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } void CheckResponse::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.CheckResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; checkresponsetype_ = 0; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* CheckResponse::_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) { // .tunnelbroker.CheckResponseType checkResponseType = 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_checkresponsetype(static_cast<::tunnelbroker::CheckResponseType>(val)); } 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* CheckResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.CheckResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // .tunnelbroker.CheckResponseType checkResponseType = 1; if (this->checkresponsetype() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_checkresponsetype(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.CheckResponse) return target; } size_t CheckResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.CheckResponse) 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; // .tunnelbroker.CheckResponseType checkResponseType = 1; if (this->checkresponsetype() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_checkresponsetype()); } 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 CheckResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.CheckResponse) GOOGLE_DCHECK_NE(&from, this); const CheckResponse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.CheckResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.CheckResponse) MergeFrom(*source); } } void CheckResponse::MergeFrom(const CheckResponse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.CheckResponse) 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.checkresponsetype() != 0) { _internal_set_checkresponsetype(from._internal_checkresponsetype()); } } void CheckResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.CheckResponse) if (&from == this) return; Clear(); MergeFrom(from); } void CheckResponse::CopyFrom(const CheckResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.CheckResponse) if (&from == this) return; Clear(); MergeFrom(from); } bool CheckResponse::IsInitialized() const { return true; } void CheckResponse::InternalSwap(CheckResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); swap(checkresponsetype_, other->checkresponsetype_); } ::PROTOBUF_NAMESPACE_ID::Metadata CheckResponse::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class NewPrimaryRequest::_Internal { public: }; NewPrimaryRequest::NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.NewPrimaryRequest) } NewPrimaryRequest::NewPrimaryRequest(const NewPrimaryRequest& 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()); } devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_devicetoken().empty()) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_devicetoken(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.NewPrimaryRequest) } void NewPrimaryRequest::SharedCtor() { userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } NewPrimaryRequest::~NewPrimaryRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.NewPrimaryRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void NewPrimaryRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void NewPrimaryRequest::ArenaDtor(void* object) { NewPrimaryRequest* _this = reinterpret_cast< NewPrimaryRequest* >(object); (void)_this; } void NewPrimaryRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NewPrimaryRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void NewPrimaryRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.NewPrimaryRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; userid_.ClearToEmpty(); devicetoken_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NewPrimaryRequest::_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, "tunnelbroker.NewPrimaryRequest.userId")); CHK_(ptr); } else goto handle_unusual; continue; // string deviceToken = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_devicetoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.NewPrimaryRequest.deviceToken")); 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* NewPrimaryRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.NewPrimaryRequest) ::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, "tunnelbroker.NewPrimaryRequest.userId"); target = stream->WriteStringMaybeAliased( 1, this->_internal_userid(), target); } // string deviceToken = 2; if (this->devicetoken().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_devicetoken().data(), static_cast(this->_internal_devicetoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.NewPrimaryRequest.deviceToken"); target = stream->WriteStringMaybeAliased( 2, this->_internal_devicetoken(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.NewPrimaryRequest) return target; } size_t NewPrimaryRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.NewPrimaryRequest) 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 deviceToken = 2; if (this->devicetoken().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_devicetoken()); } 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 NewPrimaryRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.NewPrimaryRequest) GOOGLE_DCHECK_NE(&from, this); const NewPrimaryRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.NewPrimaryRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.NewPrimaryRequest) MergeFrom(*source); } } void NewPrimaryRequest::MergeFrom(const NewPrimaryRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.NewPrimaryRequest) 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.devicetoken().size() > 0) { _internal_set_devicetoken(from._internal_devicetoken()); } } void NewPrimaryRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.NewPrimaryRequest) if (&from == this) return; Clear(); MergeFrom(from); } void NewPrimaryRequest::CopyFrom(const NewPrimaryRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.NewPrimaryRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool NewPrimaryRequest::IsInitialized() const { return true; } void NewPrimaryRequest::InternalSwap(NewPrimaryRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); devicetoken_.Swap(&other->devicetoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata NewPrimaryRequest::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class NewPrimaryResponse::_Internal { public: }; NewPrimaryResponse::NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.NewPrimaryResponse) } NewPrimaryResponse::NewPrimaryResponse(const NewPrimaryResponse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); success_ = from.success_; // @@protoc_insertion_point(copy_constructor:tunnelbroker.NewPrimaryResponse) } void NewPrimaryResponse::SharedCtor() { success_ = false; } NewPrimaryResponse::~NewPrimaryResponse() { // @@protoc_insertion_point(destructor:tunnelbroker.NewPrimaryResponse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void NewPrimaryResponse::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } void NewPrimaryResponse::ArenaDtor(void* object) { NewPrimaryResponse* _this = reinterpret_cast< NewPrimaryResponse* >(object); (void)_this; } void NewPrimaryResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void NewPrimaryResponse::SetCachedSize(int size) const { _cached_size_.Set(size); } void NewPrimaryResponse::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.NewPrimaryResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; success_ = false; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* NewPrimaryResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { // bool success = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { ctx->SetLastTag(tag); goto success; } ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), ptr, ctx); CHK_(ptr != nullptr); continue; } } // switch } // while success: return ptr; failure: ptr = nullptr; goto success; #undef CHK_ } ::PROTOBUF_NAMESPACE_ID::uint8* NewPrimaryResponse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.NewPrimaryResponse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; // bool success = 1; if (this->success() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_success(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.NewPrimaryResponse) return target; } size_t NewPrimaryResponse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.NewPrimaryResponse) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool success = 1; if (this->success() != 0) { total_size += 1 + 1; } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); SetCachedSize(cached_size); return total_size; } void NewPrimaryResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.NewPrimaryResponse) GOOGLE_DCHECK_NE(&from, this); const NewPrimaryResponse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.NewPrimaryResponse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.NewPrimaryResponse) MergeFrom(*source); } } void NewPrimaryResponse::MergeFrom(const NewPrimaryResponse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.NewPrimaryResponse) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.success() != 0) { _internal_set_success(from._internal_success()); } } void NewPrimaryResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.NewPrimaryResponse) if (&from == this) return; Clear(); MergeFrom(from); } void NewPrimaryResponse::CopyFrom(const NewPrimaryResponse& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.NewPrimaryResponse) if (&from == this) return; Clear(); MergeFrom(from); } bool NewPrimaryResponse::IsInitialized() const { return true; } void NewPrimaryResponse::InternalSwap(NewPrimaryResponse* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); swap(success_, other->success_); } ::PROTOBUF_NAMESPACE_ID::Metadata NewPrimaryResponse::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== class PongRequest::_Internal { public: }; PongRequest::PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:tunnelbroker.PongRequest) } PongRequest::PongRequest(const PongRequest& 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()); } devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from._internal_devicetoken().empty()) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_devicetoken(), GetArena()); } // @@protoc_insertion_point(copy_constructor:tunnelbroker.PongRequest) } void PongRequest::SharedCtor() { userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } PongRequest::~PongRequest() { // @@protoc_insertion_point(destructor:tunnelbroker.PongRequest) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void PongRequest::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); devicetoken_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void PongRequest::ArenaDtor(void* object) { PongRequest* _this = reinterpret_cast< PongRequest* >(object); (void)_this; } void PongRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } void PongRequest::SetCachedSize(int size) const { _cached_size_.Set(size); } void PongRequest::Clear() { // @@protoc_insertion_point(message_clear_start:tunnelbroker.PongRequest) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; userid_.ClearToEmpty(); devicetoken_.ClearToEmpty(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* PongRequest::_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, "tunnelbroker.PongRequest.userId")); CHK_(ptr); } else goto handle_unusual; continue; // string deviceToken = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_devicetoken(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "tunnelbroker.PongRequest.deviceToken")); 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* PongRequest::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:tunnelbroker.PongRequest) ::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, "tunnelbroker.PongRequest.userId"); target = stream->WriteStringMaybeAliased( 1, this->_internal_userid(), target); } // string deviceToken = 2; if (this->devicetoken().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_devicetoken().data(), static_cast(this->_internal_devicetoken().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "tunnelbroker.PongRequest.deviceToken"); target = stream->WriteStringMaybeAliased( 2, this->_internal_devicetoken(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } // @@protoc_insertion_point(serialize_to_array_end:tunnelbroker.PongRequest) return target; } size_t PongRequest::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:tunnelbroker.PongRequest) 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 deviceToken = 2; if (this->devicetoken().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_devicetoken()); } 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 PongRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_merge_from_start:tunnelbroker.PongRequest) GOOGLE_DCHECK_NE(&from, this); const PongRequest* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { // @@protoc_insertion_point(generalized_merge_from_cast_fail:tunnelbroker.PongRequest) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { // @@protoc_insertion_point(generalized_merge_from_cast_success:tunnelbroker.PongRequest) MergeFrom(*source); } } void PongRequest::MergeFrom(const PongRequest& from) { // @@protoc_insertion_point(class_specific_merge_from_start:tunnelbroker.PongRequest) 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.devicetoken().size() > 0) { _internal_set_devicetoken(from._internal_devicetoken()); } } void PongRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { // @@protoc_insertion_point(generalized_copy_from_start:tunnelbroker.PongRequest) if (&from == this) return; Clear(); MergeFrom(from); } void PongRequest::CopyFrom(const PongRequest& from) { // @@protoc_insertion_point(class_specific_copy_from_start:tunnelbroker.PongRequest) if (&from == this) return; Clear(); MergeFrom(from); } bool PongRequest::IsInitialized() const { return true; } void PongRequest::InternalSwap(PongRequest* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); userid_.Swap(&other->userid_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); devicetoken_.Swap(&other->devicetoken_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } ::PROTOBUF_NAMESPACE_ID::Metadata PongRequest::GetMetadata() const { return GetMetadataStatic(); } // @@protoc_insertion_point(namespace_scope) } // namespace tunnelbroker PROTOBUF_NAMESPACE_OPEN template<> PROTOBUF_NOINLINE ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage< ::tunnelbroker::SessionSignatureRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::SessionSignatureRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::SessionSignatureResponse* Arena::CreateMaybeMessage< ::tunnelbroker::SessionSignatureResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::SessionSignatureResponse >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage< ::tunnelbroker::NewSessionRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::NewSessionRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage< ::tunnelbroker::NewSessionResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::NewSessionResponse >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage< ::tunnelbroker::SendRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::SendRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage< ::tunnelbroker::GetRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::GetRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponseMessage* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponseMessage >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::GetResponseMessage >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage< ::tunnelbroker::GetResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::GetResponse >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::ProcessedMessages* Arena::CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::ProcessedMessages >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToTunnelbrokerStruct* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToTunnelbrokerStruct >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessageToTunnelbrokerStruct >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessagesToSend* Arena::CreateMaybeMessage< ::tunnelbroker::MessagesToSend >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessagesToSend >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToTunnelbroker* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToTunnelbroker >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessageToTunnelbroker >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToClientStruct* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToClientStruct >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessageToClientStruct >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessagesToDeliver* Arena::CreateMaybeMessage< ::tunnelbroker::MessagesToDeliver >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessagesToDeliver >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::MessageToClient* Arena::CreateMaybeMessage< ::tunnelbroker::MessageToClient >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::MessageToClient >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage< ::tunnelbroker::CheckRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::CheckRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage< ::tunnelbroker::CheckResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::CheckResponse >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage< ::tunnelbroker::NewPrimaryRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::NewPrimaryRequest >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage< ::tunnelbroker::NewPrimaryResponse >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::NewPrimaryResponse >(arena); } template<> PROTOBUF_NOINLINE ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage< ::tunnelbroker::PongRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::tunnelbroker::PongRequest >(arena); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include diff --git a/shared/protos/_generated/tunnelbroker.pb.h b/shared/protos/_generated/tunnelbroker.pb.h index 2903754cf..8edd3e727 100644 --- a/shared/protos/_generated/tunnelbroker.pb.h +++ b/shared/protos/_generated/tunnelbroker.pb.h @@ -1,6966 +1,6887 @@ // @generated by the protocol buffer compiler. DO NOT EDIT! // source: tunnelbroker.proto #ifndef GOOGLE_PROTOBUF_INCLUDED_tunnelbroker_2eproto #define GOOGLE_PROTOBUF_INCLUDED_tunnelbroker_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 #include // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_tunnelbroker_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; } // namespace internal PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct TableStruct_tunnelbroker_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[20] 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_tunnelbroker_2eproto; ::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_tunnelbroker_2eproto_metadata_getter(int index); namespace tunnelbroker { class CheckRequest; struct CheckRequestDefaultTypeInternal; extern CheckRequestDefaultTypeInternal _CheckRequest_default_instance_; class CheckResponse; struct CheckResponseDefaultTypeInternal; extern CheckResponseDefaultTypeInternal _CheckResponse_default_instance_; class GetRequest; struct GetRequestDefaultTypeInternal; extern GetRequestDefaultTypeInternal _GetRequest_default_instance_; class GetResponse; struct GetResponseDefaultTypeInternal; extern GetResponseDefaultTypeInternal _GetResponse_default_instance_; class GetResponseMessage; struct GetResponseMessageDefaultTypeInternal; extern GetResponseMessageDefaultTypeInternal _GetResponseMessage_default_instance_; class MessageToClient; struct MessageToClientDefaultTypeInternal; extern MessageToClientDefaultTypeInternal _MessageToClient_default_instance_; class MessageToClientStruct; struct MessageToClientStructDefaultTypeInternal; extern MessageToClientStructDefaultTypeInternal _MessageToClientStruct_default_instance_; class MessageToTunnelbroker; struct MessageToTunnelbrokerDefaultTypeInternal; extern MessageToTunnelbrokerDefaultTypeInternal _MessageToTunnelbroker_default_instance_; class MessageToTunnelbrokerStruct; struct MessageToTunnelbrokerStructDefaultTypeInternal; extern MessageToTunnelbrokerStructDefaultTypeInternal _MessageToTunnelbrokerStruct_default_instance_; class MessagesToDeliver; struct MessagesToDeliverDefaultTypeInternal; extern MessagesToDeliverDefaultTypeInternal _MessagesToDeliver_default_instance_; class MessagesToSend; struct MessagesToSendDefaultTypeInternal; extern MessagesToSendDefaultTypeInternal _MessagesToSend_default_instance_; class NewPrimaryRequest; struct NewPrimaryRequestDefaultTypeInternal; extern NewPrimaryRequestDefaultTypeInternal _NewPrimaryRequest_default_instance_; class NewPrimaryResponse; struct NewPrimaryResponseDefaultTypeInternal; extern NewPrimaryResponseDefaultTypeInternal _NewPrimaryResponse_default_instance_; class NewSessionRequest; struct NewSessionRequestDefaultTypeInternal; extern NewSessionRequestDefaultTypeInternal _NewSessionRequest_default_instance_; class NewSessionResponse; struct NewSessionResponseDefaultTypeInternal; extern NewSessionResponseDefaultTypeInternal _NewSessionResponse_default_instance_; class PongRequest; struct PongRequestDefaultTypeInternal; extern PongRequestDefaultTypeInternal _PongRequest_default_instance_; class ProcessedMessages; struct ProcessedMessagesDefaultTypeInternal; extern ProcessedMessagesDefaultTypeInternal _ProcessedMessages_default_instance_; class SendRequest; struct SendRequestDefaultTypeInternal; extern SendRequestDefaultTypeInternal _SendRequest_default_instance_; class SessionSignatureRequest; struct SessionSignatureRequestDefaultTypeInternal; extern SessionSignatureRequestDefaultTypeInternal _SessionSignatureRequest_default_instance_; class SessionSignatureResponse; struct SessionSignatureResponseDefaultTypeInternal; extern SessionSignatureResponseDefaultTypeInternal _SessionSignatureResponse_default_instance_; } // namespace tunnelbroker PROTOBUF_NAMESPACE_OPEN template<> ::tunnelbroker::CheckRequest* Arena::CreateMaybeMessage<::tunnelbroker::CheckRequest>(Arena*); template<> ::tunnelbroker::CheckResponse* Arena::CreateMaybeMessage<::tunnelbroker::CheckResponse>(Arena*); template<> ::tunnelbroker::GetRequest* Arena::CreateMaybeMessage<::tunnelbroker::GetRequest>(Arena*); template<> ::tunnelbroker::GetResponse* Arena::CreateMaybeMessage<::tunnelbroker::GetResponse>(Arena*); template<> ::tunnelbroker::GetResponseMessage* Arena::CreateMaybeMessage<::tunnelbroker::GetResponseMessage>(Arena*); template<> ::tunnelbroker::MessageToClient* Arena::CreateMaybeMessage<::tunnelbroker::MessageToClient>(Arena*); template<> ::tunnelbroker::MessageToClientStruct* Arena::CreateMaybeMessage<::tunnelbroker::MessageToClientStruct>(Arena*); template<> ::tunnelbroker::MessageToTunnelbroker* Arena::CreateMaybeMessage<::tunnelbroker::MessageToTunnelbroker>(Arena*); template<> ::tunnelbroker::MessageToTunnelbrokerStruct* Arena::CreateMaybeMessage<::tunnelbroker::MessageToTunnelbrokerStruct>(Arena*); template<> ::tunnelbroker::MessagesToDeliver* Arena::CreateMaybeMessage<::tunnelbroker::MessagesToDeliver>(Arena*); template<> ::tunnelbroker::MessagesToSend* Arena::CreateMaybeMessage<::tunnelbroker::MessagesToSend>(Arena*); template<> ::tunnelbroker::NewPrimaryRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryRequest>(Arena*); template<> ::tunnelbroker::NewPrimaryResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewPrimaryResponse>(Arena*); template<> ::tunnelbroker::NewSessionRequest* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionRequest>(Arena*); template<> ::tunnelbroker::NewSessionResponse* Arena::CreateMaybeMessage<::tunnelbroker::NewSessionResponse>(Arena*); template<> ::tunnelbroker::PongRequest* Arena::CreateMaybeMessage<::tunnelbroker::PongRequest>(Arena*); template<> ::tunnelbroker::ProcessedMessages* Arena::CreateMaybeMessage<::tunnelbroker::ProcessedMessages>(Arena*); template<> ::tunnelbroker::SendRequest* Arena::CreateMaybeMessage<::tunnelbroker::SendRequest>(Arena*); template<> ::tunnelbroker::SessionSignatureRequest* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureRequest>(Arena*); template<> ::tunnelbroker::SessionSignatureResponse* Arena::CreateMaybeMessage<::tunnelbroker::SessionSignatureResponse>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace tunnelbroker { enum NewSessionRequest_DeviceTypes : int { NewSessionRequest_DeviceTypes_MOBILE = 0, NewSessionRequest_DeviceTypes_WEB = 1, NewSessionRequest_DeviceTypes_KEYSERVER = 2, NewSessionRequest_DeviceTypes_NewSessionRequest_DeviceTypes_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), NewSessionRequest_DeviceTypes_NewSessionRequest_DeviceTypes_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool NewSessionRequest_DeviceTypes_IsValid(int value); constexpr NewSessionRequest_DeviceTypes NewSessionRequest_DeviceTypes_DeviceTypes_MIN = NewSessionRequest_DeviceTypes_MOBILE; constexpr NewSessionRequest_DeviceTypes NewSessionRequest_DeviceTypes_DeviceTypes_MAX = NewSessionRequest_DeviceTypes_KEYSERVER; constexpr int NewSessionRequest_DeviceTypes_DeviceTypes_ARRAYSIZE = NewSessionRequest_DeviceTypes_DeviceTypes_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NewSessionRequest_DeviceTypes_descriptor(); template inline const std::string& NewSessionRequest_DeviceTypes_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function NewSessionRequest_DeviceTypes_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( NewSessionRequest_DeviceTypes_descriptor(), enum_t_value); } inline bool NewSessionRequest_DeviceTypes_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NewSessionRequest_DeviceTypes* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( NewSessionRequest_DeviceTypes_descriptor(), name, value); } enum CheckResponseType : int { PRIMARY_DOESNT_EXIST = 0, PRIMARY_ONLINE = 1, PRIMARY_OFFLINE = 2, CURRENT_IS_PRIMARY = 3, CheckResponseType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), CheckResponseType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool CheckResponseType_IsValid(int value); constexpr CheckResponseType CheckResponseType_MIN = PRIMARY_DOESNT_EXIST; constexpr CheckResponseType CheckResponseType_MAX = CURRENT_IS_PRIMARY; constexpr int CheckResponseType_ARRAYSIZE = CheckResponseType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CheckResponseType_descriptor(); template inline const std::string& CheckResponseType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CheckResponseType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( CheckResponseType_descriptor(), enum_t_value); } inline bool CheckResponseType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CheckResponseType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( CheckResponseType_descriptor(), name, value); } // =================================================================== class SessionSignatureRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.SessionSignatureRequest) */ { public: inline SessionSignatureRequest() : SessionSignatureRequest(nullptr) {} virtual ~SessionSignatureRequest(); explicit constexpr SessionSignatureRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SessionSignatureRequest(const SessionSignatureRequest& from); SessionSignatureRequest(SessionSignatureRequest&& from) noexcept : SessionSignatureRequest() { *this = ::std::move(from); } inline SessionSignatureRequest& operator=(const SessionSignatureRequest& from) { CopyFrom(from); return *this; } inline SessionSignatureRequest& operator=(SessionSignatureRequest&& 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 SessionSignatureRequest& default_instance() { return *internal_default_instance(); } static inline const SessionSignatureRequest* internal_default_instance() { return reinterpret_cast( &_SessionSignatureRequest_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(SessionSignatureRequest& a, SessionSignatureRequest& b) { a.Swap(&b); } inline void Swap(SessionSignatureRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SessionSignatureRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline SessionSignatureRequest* New() const final { return CreateMaybeMessage(nullptr); } SessionSignatureRequest* 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 SessionSignatureRequest& from); void MergeFrom(const SessionSignatureRequest& 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(SessionSignatureRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.SessionSignatureRequest"; } protected: explicit SessionSignatureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDeviceIDFieldNumber = 1, }; // string deviceID = 1; 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:tunnelbroker.SessionSignatureRequest) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class SessionSignatureResponse PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.SessionSignatureResponse) */ { public: inline SessionSignatureResponse() : SessionSignatureResponse(nullptr) {} virtual ~SessionSignatureResponse(); explicit constexpr SessionSignatureResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SessionSignatureResponse(const SessionSignatureResponse& from); SessionSignatureResponse(SessionSignatureResponse&& from) noexcept : SessionSignatureResponse() { *this = ::std::move(from); } inline SessionSignatureResponse& operator=(const SessionSignatureResponse& from) { CopyFrom(from); return *this; } inline SessionSignatureResponse& operator=(SessionSignatureResponse&& 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 SessionSignatureResponse& default_instance() { return *internal_default_instance(); } static inline const SessionSignatureResponse* internal_default_instance() { return reinterpret_cast( &_SessionSignatureResponse_default_instance_); } static constexpr int kIndexInFileMessages = 1; friend void swap(SessionSignatureResponse& a, SessionSignatureResponse& b) { a.Swap(&b); } inline void Swap(SessionSignatureResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SessionSignatureResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline SessionSignatureResponse* New() const final { return CreateMaybeMessage(nullptr); } SessionSignatureResponse* 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 SessionSignatureResponse& from); void MergeFrom(const SessionSignatureResponse& 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(SessionSignatureResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.SessionSignatureResponse"; } protected: explicit SessionSignatureResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kToSignFieldNumber = 1, }; // string toSign = 1; void clear_tosign(); const std::string& tosign() const; void set_tosign(const std::string& value); void set_tosign(std::string&& value); void set_tosign(const char* value); void set_tosign(const char* value, size_t size); std::string* mutable_tosign(); std::string* release_tosign(); void set_allocated_tosign(std::string* tosign); private: const std::string& _internal_tosign() const; void _internal_set_tosign(const std::string& value); std::string* _internal_mutable_tosign(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.SessionSignatureResponse) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tosign_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class NewSessionRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewSessionRequest) */ { public: inline NewSessionRequest() : NewSessionRequest(nullptr) {} virtual ~NewSessionRequest(); explicit constexpr NewSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NewSessionRequest(const NewSessionRequest& from); NewSessionRequest(NewSessionRequest&& from) noexcept : NewSessionRequest() { *this = ::std::move(from); } inline NewSessionRequest& operator=(const NewSessionRequest& from) { CopyFrom(from); return *this; } inline NewSessionRequest& operator=(NewSessionRequest&& 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 NewSessionRequest& default_instance() { return *internal_default_instance(); } static inline const NewSessionRequest* internal_default_instance() { return reinterpret_cast( &_NewSessionRequest_default_instance_); } static constexpr int kIndexInFileMessages = 2; friend void swap(NewSessionRequest& a, NewSessionRequest& b) { a.Swap(&b); } inline void Swap(NewSessionRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NewSessionRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline NewSessionRequest* New() const final { return CreateMaybeMessage(nullptr); } NewSessionRequest* 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 NewSessionRequest& from); void MergeFrom(const NewSessionRequest& 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(NewSessionRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.NewSessionRequest"; } protected: explicit NewSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- typedef NewSessionRequest_DeviceTypes DeviceTypes; static constexpr DeviceTypes MOBILE = NewSessionRequest_DeviceTypes_MOBILE; static constexpr DeviceTypes WEB = NewSessionRequest_DeviceTypes_WEB; static constexpr DeviceTypes KEYSERVER = NewSessionRequest_DeviceTypes_KEYSERVER; static inline bool DeviceTypes_IsValid(int value) { return NewSessionRequest_DeviceTypes_IsValid(value); } static constexpr DeviceTypes DeviceTypes_MIN = NewSessionRequest_DeviceTypes_DeviceTypes_MIN; static constexpr DeviceTypes DeviceTypes_MAX = NewSessionRequest_DeviceTypes_DeviceTypes_MAX; static constexpr int DeviceTypes_ARRAYSIZE = NewSessionRequest_DeviceTypes_DeviceTypes_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceTypes_descriptor() { return NewSessionRequest_DeviceTypes_descriptor(); } template static inline const std::string& DeviceTypes_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DeviceTypes_Name."); return NewSessionRequest_DeviceTypes_Name(enum_t_value); } static inline bool DeviceTypes_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceTypes* value) { return NewSessionRequest_DeviceTypes_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kDeviceIDFieldNumber = 1, kPublicKeyFieldNumber = 2, kSignatureFieldNumber = 3, kNotifyTokenFieldNumber = 4, kDeviceAppVersionFieldNumber = 6, kDeviceOSFieldNumber = 7, kDeviceTypeFieldNumber = 5, }; // string deviceID = 1; 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 publicKey = 2; void clear_publickey(); const std::string& publickey() const; void set_publickey(const std::string& value); void set_publickey(std::string&& value); void set_publickey(const char* value); void set_publickey(const 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: // string signature = 3; void clear_signature(); const std::string& signature() const; void set_signature(const std::string& value); void set_signature(std::string&& value); void set_signature(const char* value); void set_signature(const char* value, size_t size); std::string* mutable_signature(); std::string* release_signature(); void set_allocated_signature(std::string* signature); private: const std::string& _internal_signature() const; void _internal_set_signature(const std::string& value); std::string* _internal_mutable_signature(); public: // string notifyToken = 4; bool has_notifytoken() const; private: bool _internal_has_notifytoken() const; public: void clear_notifytoken(); const std::string& notifytoken() const; void set_notifytoken(const std::string& value); void set_notifytoken(std::string&& value); void set_notifytoken(const char* value); void set_notifytoken(const char* value, size_t size); std::string* mutable_notifytoken(); std::string* release_notifytoken(); void set_allocated_notifytoken(std::string* notifytoken); private: const std::string& _internal_notifytoken() const; void _internal_set_notifytoken(const std::string& value); std::string* _internal_mutable_notifytoken(); public: // string deviceAppVersion = 6; void clear_deviceappversion(); const std::string& deviceappversion() const; void set_deviceappversion(const std::string& value); void set_deviceappversion(std::string&& value); void set_deviceappversion(const char* value); void set_deviceappversion(const char* value, size_t size); std::string* mutable_deviceappversion(); std::string* release_deviceappversion(); void set_allocated_deviceappversion(std::string* deviceappversion); private: const std::string& _internal_deviceappversion() const; void _internal_set_deviceappversion(const std::string& value); std::string* _internal_mutable_deviceappversion(); public: // string deviceOS = 7; void clear_deviceos(); const std::string& deviceos() const; void set_deviceos(const std::string& value); void set_deviceos(std::string&& value); void set_deviceos(const char* value); void set_deviceos(const char* value, size_t size); std::string* mutable_deviceos(); std::string* release_deviceos(); void set_allocated_deviceos(std::string* deviceos); private: const std::string& _internal_deviceos() const; void _internal_set_deviceos(const std::string& value); std::string* _internal_mutable_deviceos(); public: // .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5; void clear_devicetype(); ::tunnelbroker::NewSessionRequest_DeviceTypes devicetype() const; void set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value); private: ::tunnelbroker::NewSessionRequest_DeviceTypes _internal_devicetype() const; void _internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value); public: // @@protoc_insertion_point(class_scope:tunnelbroker.NewSessionRequest) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publickey_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr notifytoken_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceappversion_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceos_; int devicetype_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class NewSessionResponse PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewSessionResponse) */ { public: inline NewSessionResponse() : NewSessionResponse(nullptr) {} virtual ~NewSessionResponse(); explicit constexpr NewSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NewSessionResponse(const NewSessionResponse& from); NewSessionResponse(NewSessionResponse&& from) noexcept : NewSessionResponse() { *this = ::std::move(from); } inline NewSessionResponse& operator=(const NewSessionResponse& from) { CopyFrom(from); return *this; } inline NewSessionResponse& operator=(NewSessionResponse&& 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 NewSessionResponse& default_instance() { return *internal_default_instance(); } static inline const NewSessionResponse* internal_default_instance() { return reinterpret_cast( &_NewSessionResponse_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(NewSessionResponse& a, NewSessionResponse& b) { a.Swap(&b); } inline void Swap(NewSessionResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NewSessionResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline NewSessionResponse* New() const final { return CreateMaybeMessage(nullptr); } NewSessionResponse* 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 NewSessionResponse& from); void MergeFrom(const NewSessionResponse& 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(NewSessionResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.NewSessionResponse"; } protected: explicit NewSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSessionIDFieldNumber = 1, }; // string sessionID = 1; void clear_sessionid(); const std::string& sessionid() const; void set_sessionid(const std::string& value); void set_sessionid(std::string&& value); void set_sessionid(const char* value); void set_sessionid(const char* value, size_t size); std::string* mutable_sessionid(); std::string* release_sessionid(); void set_allocated_sessionid(std::string* sessionid); private: const std::string& _internal_sessionid() const; void _internal_set_sessionid(const std::string& value); std::string* _internal_mutable_sessionid(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.NewSessionResponse) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class SendRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.SendRequest) */ { public: inline SendRequest() : SendRequest(nullptr) {} virtual ~SendRequest(); explicit constexpr SendRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); SendRequest(const SendRequest& from); SendRequest(SendRequest&& from) noexcept : SendRequest() { *this = ::std::move(from); } inline SendRequest& operator=(const SendRequest& from) { CopyFrom(from); return *this; } inline SendRequest& operator=(SendRequest&& 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 SendRequest& default_instance() { return *internal_default_instance(); } static inline const SendRequest* internal_default_instance() { return reinterpret_cast( &_SendRequest_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(SendRequest& a, SendRequest& b) { a.Swap(&b); } inline void Swap(SendRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SendRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline SendRequest* New() const final { return CreateMaybeMessage(nullptr); } SendRequest* 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 SendRequest& from); void MergeFrom(const SendRequest& 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(SendRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.SendRequest"; } protected: explicit SendRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlobHashesFieldNumber = 4, kSessionIDFieldNumber = 1, kToDeviceIDFieldNumber = 2, kPayloadFieldNumber = 3, }; // repeated string blobHashes = 4; int blobhashes_size() const; private: int _internal_blobhashes_size() const; public: void clear_blobhashes(); const std::string& blobhashes(int index) const; std::string* mutable_blobhashes(int index); void set_blobhashes(int index, const std::string& value); void set_blobhashes(int index, std::string&& value); void set_blobhashes(int index, const char* value); void set_blobhashes(int index, const char* value, size_t size); std::string* add_blobhashes(); void add_blobhashes(const std::string& value); void add_blobhashes(std::string&& value); void add_blobhashes(const char* value); void add_blobhashes(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); private: const std::string& _internal_blobhashes(int index) const; std::string* _internal_add_blobhashes(); public: // string sessionID = 1; void clear_sessionid(); const std::string& sessionid() const; void set_sessionid(const std::string& value); void set_sessionid(std::string&& value); void set_sessionid(const char* value); void set_sessionid(const char* value, size_t size); std::string* mutable_sessionid(); std::string* release_sessionid(); void set_allocated_sessionid(std::string* sessionid); private: const std::string& _internal_sessionid() const; void _internal_set_sessionid(const std::string& value); std::string* _internal_mutable_sessionid(); public: // string toDeviceID = 2; void clear_todeviceid(); const std::string& todeviceid() const; void set_todeviceid(const std::string& value); void set_todeviceid(std::string&& value); void set_todeviceid(const char* value); void set_todeviceid(const char* value, size_t size); std::string* mutable_todeviceid(); std::string* release_todeviceid(); void set_allocated_todeviceid(std::string* todeviceid); private: const std::string& _internal_todeviceid() const; void _internal_set_todeviceid(const std::string& value); std::string* _internal_mutable_todeviceid(); public: // bytes payload = 3; void clear_payload(); const std::string& payload() const; void set_payload(const std::string& value); void set_payload(std::string&& value); void set_payload(const char* value); void set_payload(const void* value, size_t size); std::string* mutable_payload(); std::string* release_payload(); void set_allocated_payload(std::string* payload); private: const std::string& _internal_payload() const; void _internal_set_payload(const std::string& value); std::string* _internal_mutable_payload(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.SendRequest) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class GetRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.GetRequest) */ { public: inline GetRequest() : GetRequest(nullptr) {} virtual ~GetRequest(); explicit constexpr GetRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GetRequest(const GetRequest& from); GetRequest(GetRequest&& from) noexcept : GetRequest() { *this = ::std::move(from); } inline GetRequest& operator=(const GetRequest& from) { CopyFrom(from); return *this; } inline GetRequest& operator=(GetRequest&& 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 GetRequest& default_instance() { return *internal_default_instance(); } static inline const GetRequest* internal_default_instance() { return reinterpret_cast( &_GetRequest_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(GetRequest& a, GetRequest& b) { a.Swap(&b); } inline void Swap(GetRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline GetRequest* New() const final { return CreateMaybeMessage(nullptr); } GetRequest* 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 GetRequest& from); void MergeFrom(const GetRequest& 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(GetRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.GetRequest"; } protected: explicit GetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSessionIDFieldNumber = 1, kNewNotifyTokenFieldNumber = 2, }; // string sessionID = 1; void clear_sessionid(); const std::string& sessionid() const; void set_sessionid(const std::string& value); void set_sessionid(std::string&& value); void set_sessionid(const char* value); void set_sessionid(const char* value, size_t size); std::string* mutable_sessionid(); std::string* release_sessionid(); void set_allocated_sessionid(std::string* sessionid); private: const std::string& _internal_sessionid() const; void _internal_set_sessionid(const std::string& value); std::string* _internal_mutable_sessionid(); public: // string newNotifyToken = 2; bool has_newnotifytoken() const; private: bool _internal_has_newnotifytoken() const; public: void clear_newnotifytoken(); const std::string& newnotifytoken() const; void set_newnotifytoken(const std::string& value); void set_newnotifytoken(std::string&& value); void set_newnotifytoken(const char* value); void set_newnotifytoken(const char* value, size_t size); std::string* mutable_newnotifytoken(); std::string* release_newnotifytoken(); void set_allocated_newnotifytoken(std::string* newnotifytoken); private: const std::string& _internal_newnotifytoken() const; void _internal_set_newnotifytoken(const std::string& value); std::string* _internal_mutable_newnotifytoken(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.GetRequest) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newnotifytoken_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class GetResponseMessage PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.GetResponseMessage) */ { public: inline GetResponseMessage() : GetResponseMessage(nullptr) {} virtual ~GetResponseMessage(); explicit constexpr GetResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GetResponseMessage(const GetResponseMessage& from); GetResponseMessage(GetResponseMessage&& from) noexcept : GetResponseMessage() { *this = ::std::move(from); } inline GetResponseMessage& operator=(const GetResponseMessage& from) { CopyFrom(from); return *this; } inline GetResponseMessage& operator=(GetResponseMessage&& 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 GetResponseMessage& default_instance() { return *internal_default_instance(); } static inline const GetResponseMessage* internal_default_instance() { return reinterpret_cast( &_GetResponseMessage_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(GetResponseMessage& a, GetResponseMessage& b) { a.Swap(&b); } inline void Swap(GetResponseMessage* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetResponseMessage* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline GetResponseMessage* New() const final { return CreateMaybeMessage(nullptr); } GetResponseMessage* 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 GetResponseMessage& from); void MergeFrom(const GetResponseMessage& 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(GetResponseMessage* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.GetResponseMessage"; } protected: explicit GetResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlobHashesFieldNumber = 3, kFromDeviceIDFieldNumber = 1, kPayloadFieldNumber = 2, }; // repeated string blobHashes = 3; int blobhashes_size() const; private: int _internal_blobhashes_size() const; public: void clear_blobhashes(); const std::string& blobhashes(int index) const; std::string* mutable_blobhashes(int index); void set_blobhashes(int index, const std::string& value); void set_blobhashes(int index, std::string&& value); void set_blobhashes(int index, const char* value); void set_blobhashes(int index, const char* value, size_t size); std::string* add_blobhashes(); void add_blobhashes(const std::string& value); void add_blobhashes(std::string&& value); void add_blobhashes(const char* value); void add_blobhashes(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); private: const std::string& _internal_blobhashes(int index) const; std::string* _internal_add_blobhashes(); public: // string fromDeviceID = 1; void clear_fromdeviceid(); const std::string& fromdeviceid() const; void set_fromdeviceid(const std::string& value); void set_fromdeviceid(std::string&& value); void set_fromdeviceid(const char* value); void set_fromdeviceid(const char* value, size_t size); std::string* mutable_fromdeviceid(); std::string* release_fromdeviceid(); void set_allocated_fromdeviceid(std::string* fromdeviceid); private: const std::string& _internal_fromdeviceid() const; void _internal_set_fromdeviceid(const std::string& value); std::string* _internal_mutable_fromdeviceid(); public: // bytes payload = 2; void clear_payload(); const std::string& payload() const; void set_payload(const std::string& value); void set_payload(std::string&& value); void set_payload(const char* value); void set_payload(const void* value, size_t size); std::string* mutable_payload(); std::string* release_payload(); void set_allocated_payload(std::string* payload); private: const std::string& _internal_payload() const; void _internal_set_payload(const std::string& value); std::string* _internal_mutable_payload(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.GetResponseMessage) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class GetResponse PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.GetResponse) */ { public: inline GetResponse() : GetResponse(nullptr) {} virtual ~GetResponse(); explicit constexpr GetResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GetResponse(const GetResponse& from); GetResponse(GetResponse&& from) noexcept : GetResponse() { *this = ::std::move(from); } inline GetResponse& operator=(const GetResponse& from) { CopyFrom(from); return *this; } inline GetResponse& operator=(GetResponse&& 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 GetResponse& default_instance() { return *internal_default_instance(); } enum DataCase { kResponseMessage = 1, kPing = 2, kNewNotifyTokenRequired = 3, DATA_NOT_SET = 0, }; static inline const GetResponse* internal_default_instance() { return reinterpret_cast( &_GetResponse_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(GetResponse& a, GetResponse& b) { a.Swap(&b); } inline void Swap(GetResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GetResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline GetResponse* New() const final { return CreateMaybeMessage(nullptr); } GetResponse* 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 GetResponse& from); void MergeFrom(const GetResponse& 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(GetResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.GetResponse"; } protected: explicit GetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kResponseMessageFieldNumber = 1, kPingFieldNumber = 2, kNewNotifyTokenRequiredFieldNumber = 3, }; // .tunnelbroker.GetResponseMessage responseMessage = 1; bool has_responsemessage() const; private: bool _internal_has_responsemessage() const; public: void clear_responsemessage(); const ::tunnelbroker::GetResponseMessage& responsemessage() const; ::tunnelbroker::GetResponseMessage* release_responsemessage(); ::tunnelbroker::GetResponseMessage* mutable_responsemessage(); void set_allocated_responsemessage(::tunnelbroker::GetResponseMessage* responsemessage); private: const ::tunnelbroker::GetResponseMessage& _internal_responsemessage() const; ::tunnelbroker::GetResponseMessage* _internal_mutable_responsemessage(); public: void unsafe_arena_set_allocated_responsemessage( ::tunnelbroker::GetResponseMessage* responsemessage); ::tunnelbroker::GetResponseMessage* unsafe_arena_release_responsemessage(); // .google.protobuf.Empty ping = 2; bool has_ping() const; private: bool _internal_has_ping() const; public: void clear_ping(); const PROTOBUF_NAMESPACE_ID::Empty& ping() const; PROTOBUF_NAMESPACE_ID::Empty* release_ping(); PROTOBUF_NAMESPACE_ID::Empty* mutable_ping(); void set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping); private: const PROTOBUF_NAMESPACE_ID::Empty& _internal_ping() const; PROTOBUF_NAMESPACE_ID::Empty* _internal_mutable_ping(); public: void unsafe_arena_set_allocated_ping( PROTOBUF_NAMESPACE_ID::Empty* ping); PROTOBUF_NAMESPACE_ID::Empty* unsafe_arena_release_ping(); // .google.protobuf.Empty newNotifyTokenRequired = 3; bool has_newnotifytokenrequired() const; private: bool _internal_has_newnotifytokenrequired() const; public: void clear_newnotifytokenrequired(); const PROTOBUF_NAMESPACE_ID::Empty& newnotifytokenrequired() const; PROTOBUF_NAMESPACE_ID::Empty* release_newnotifytokenrequired(); PROTOBUF_NAMESPACE_ID::Empty* mutable_newnotifytokenrequired(); void set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired); private: const PROTOBUF_NAMESPACE_ID::Empty& _internal_newnotifytokenrequired() const; PROTOBUF_NAMESPACE_ID::Empty* _internal_mutable_newnotifytokenrequired(); public: void unsafe_arena_set_allocated_newnotifytokenrequired( PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired); PROTOBUF_NAMESPACE_ID::Empty* unsafe_arena_release_newnotifytokenrequired(); void clear_data(); DataCase data_case() const; // @@protoc_insertion_point(class_scope:tunnelbroker.GetResponse) private: class _Internal; void set_has_responsemessage(); void set_has_ping(); void set_has_newnotifytokenrequired(); 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_; ::tunnelbroker::GetResponseMessage* responsemessage_; PROTOBUF_NAMESPACE_ID::Empty* ping_; PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired_; } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class ProcessedMessages PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.ProcessedMessages) */ { public: inline ProcessedMessages() : ProcessedMessages(nullptr) {} virtual ~ProcessedMessages(); explicit constexpr ProcessedMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ProcessedMessages(const ProcessedMessages& from); ProcessedMessages(ProcessedMessages&& from) noexcept : ProcessedMessages() { *this = ::std::move(from); } inline ProcessedMessages& operator=(const ProcessedMessages& from) { CopyFrom(from); return *this; } inline ProcessedMessages& operator=(ProcessedMessages&& 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 ProcessedMessages& default_instance() { return *internal_default_instance(); } static inline const ProcessedMessages* internal_default_instance() { return reinterpret_cast( &_ProcessedMessages_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(ProcessedMessages& a, ProcessedMessages& b) { a.Swap(&b); } inline void Swap(ProcessedMessages* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ProcessedMessages* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline ProcessedMessages* New() const final { return CreateMaybeMessage(nullptr); } ProcessedMessages* 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 ProcessedMessages& from); void MergeFrom(const ProcessedMessages& 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(ProcessedMessages* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.ProcessedMessages"; } protected: explicit ProcessedMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMessageIDFieldNumber = 1, }; // repeated string messageID = 1; int messageid_size() const; private: int _internal_messageid_size() const; public: void clear_messageid(); const std::string& messageid(int index) const; std::string* mutable_messageid(int index); void set_messageid(int index, const std::string& value); void set_messageid(int index, std::string&& value); void set_messageid(int index, const char* value); void set_messageid(int index, const char* value, size_t size); std::string* add_messageid(); void add_messageid(const std::string& value); void add_messageid(std::string&& value); void add_messageid(const char* value); void add_messageid(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& messageid() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_messageid(); private: const std::string& _internal_messageid(int index) const; std::string* _internal_add_messageid(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.ProcessedMessages) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField messageid_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessageToTunnelbrokerStruct PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToTunnelbrokerStruct) */ { public: inline MessageToTunnelbrokerStruct() : MessageToTunnelbrokerStruct(nullptr) {} virtual ~MessageToTunnelbrokerStruct(); explicit constexpr MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessageToTunnelbrokerStruct(const MessageToTunnelbrokerStruct& from); MessageToTunnelbrokerStruct(MessageToTunnelbrokerStruct&& from) noexcept : MessageToTunnelbrokerStruct() { *this = ::std::move(from); } inline MessageToTunnelbrokerStruct& operator=(const MessageToTunnelbrokerStruct& from) { CopyFrom(from); return *this; } inline MessageToTunnelbrokerStruct& operator=(MessageToTunnelbrokerStruct&& 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 MessageToTunnelbrokerStruct& default_instance() { return *internal_default_instance(); } static inline const MessageToTunnelbrokerStruct* internal_default_instance() { return reinterpret_cast( &_MessageToTunnelbrokerStruct_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(MessageToTunnelbrokerStruct& a, MessageToTunnelbrokerStruct& b) { a.Swap(&b); } inline void Swap(MessageToTunnelbrokerStruct* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessageToTunnelbrokerStruct* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessageToTunnelbrokerStruct* New() const final { return CreateMaybeMessage(nullptr); } MessageToTunnelbrokerStruct* 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 MessageToTunnelbrokerStruct& from); void MergeFrom(const MessageToTunnelbrokerStruct& 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(MessageToTunnelbrokerStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessageToTunnelbrokerStruct"; } protected: explicit MessageToTunnelbrokerStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlobHashesFieldNumber = 4, kMessageIDFieldNumber = 1, kToDeviceIDFieldNumber = 2, kPayloadFieldNumber = 3, }; // repeated string blobHashes = 4; int blobhashes_size() const; private: int _internal_blobhashes_size() const; public: void clear_blobhashes(); const std::string& blobhashes(int index) const; std::string* mutable_blobhashes(int index); void set_blobhashes(int index, const std::string& value); void set_blobhashes(int index, std::string&& value); void set_blobhashes(int index, const char* value); void set_blobhashes(int index, const char* value, size_t size); std::string* add_blobhashes(); void add_blobhashes(const std::string& value); void add_blobhashes(std::string&& value); void add_blobhashes(const char* value); void add_blobhashes(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); private: const std::string& _internal_blobhashes(int index) const; std::string* _internal_add_blobhashes(); public: // string messageID = 1; void clear_messageid(); const std::string& messageid() const; void set_messageid(const std::string& value); void set_messageid(std::string&& value); void set_messageid(const char* value); void set_messageid(const char* value, size_t size); std::string* mutable_messageid(); std::string* release_messageid(); void set_allocated_messageid(std::string* messageid); private: const std::string& _internal_messageid() const; void _internal_set_messageid(const std::string& value); std::string* _internal_mutable_messageid(); public: // string toDeviceID = 2; void clear_todeviceid(); const std::string& todeviceid() const; void set_todeviceid(const std::string& value); void set_todeviceid(std::string&& value); void set_todeviceid(const char* value); void set_todeviceid(const char* value, size_t size); std::string* mutable_todeviceid(); std::string* release_todeviceid(); void set_allocated_todeviceid(std::string* todeviceid); private: const std::string& _internal_todeviceid() const; void _internal_set_todeviceid(const std::string& value); std::string* _internal_mutable_todeviceid(); public: // string payload = 3; void clear_payload(); const std::string& payload() const; void set_payload(const std::string& value); void set_payload(std::string&& value); void set_payload(const char* value); void set_payload(const char* value, size_t size); std::string* mutable_payload(); std::string* release_payload(); void set_allocated_payload(std::string* payload); private: const std::string& _internal_payload() const; void _internal_set_payload(const std::string& value); std::string* _internal_mutable_payload(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToTunnelbrokerStruct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr todeviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessagesToSend PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessagesToSend) */ { public: inline MessagesToSend() : MessagesToSend(nullptr) {} virtual ~MessagesToSend(); explicit constexpr MessagesToSend(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessagesToSend(const MessagesToSend& from); MessagesToSend(MessagesToSend&& from) noexcept : MessagesToSend() { *this = ::std::move(from); } inline MessagesToSend& operator=(const MessagesToSend& from) { CopyFrom(from); return *this; } inline MessagesToSend& operator=(MessagesToSend&& 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 MessagesToSend& default_instance() { return *internal_default_instance(); } static inline const MessagesToSend* internal_default_instance() { return reinterpret_cast( &_MessagesToSend_default_instance_); } static constexpr int kIndexInFileMessages = 10; friend void swap(MessagesToSend& a, MessagesToSend& b) { a.Swap(&b); } inline void Swap(MessagesToSend* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessagesToSend* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessagesToSend* New() const final { return CreateMaybeMessage(nullptr); } MessagesToSend* 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 MessagesToSend& from); void MergeFrom(const MessagesToSend& 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(MessagesToSend* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessagesToSend"; } protected: explicit MessagesToSend(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMessagesFieldNumber = 1, }; // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; int messages_size() const; private: int _internal_messages_size() const; public: void clear_messages(); ::tunnelbroker::MessageToTunnelbrokerStruct* mutable_messages(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >* mutable_messages(); private: const ::tunnelbroker::MessageToTunnelbrokerStruct& _internal_messages(int index) const; ::tunnelbroker::MessageToTunnelbrokerStruct* _internal_add_messages(); public: const ::tunnelbroker::MessageToTunnelbrokerStruct& messages(int index) const; ::tunnelbroker::MessageToTunnelbrokerStruct* add_messages(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >& messages() const; // @@protoc_insertion_point(class_scope:tunnelbroker.MessagesToSend) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct > messages_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessageToTunnelbroker PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToTunnelbroker) */ { public: inline MessageToTunnelbroker() : MessageToTunnelbroker(nullptr) {} virtual ~MessageToTunnelbroker(); explicit constexpr MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessageToTunnelbroker(const MessageToTunnelbroker& from); MessageToTunnelbroker(MessageToTunnelbroker&& from) noexcept : MessageToTunnelbroker() { *this = ::std::move(from); } inline MessageToTunnelbroker& operator=(const MessageToTunnelbroker& from) { CopyFrom(from); return *this; } inline MessageToTunnelbroker& operator=(MessageToTunnelbroker&& 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 MessageToTunnelbroker& default_instance() { return *internal_default_instance(); } enum DataCase { - kMessagesToSend = 2, - kProcessedMessages = 3, - kNewNotifyToken = 4, + kMessagesToSend = 1, + kProcessedMessages = 2, + kNewNotifyToken = 3, DATA_NOT_SET = 0, }; static inline const MessageToTunnelbroker* internal_default_instance() { return reinterpret_cast( &_MessageToTunnelbroker_default_instance_); } static constexpr int kIndexInFileMessages = 11; friend void swap(MessageToTunnelbroker& a, MessageToTunnelbroker& b) { a.Swap(&b); } inline void Swap(MessageToTunnelbroker* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessageToTunnelbroker* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessageToTunnelbroker* New() const final { return CreateMaybeMessage(nullptr); } MessageToTunnelbroker* 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 MessageToTunnelbroker& from); void MergeFrom(const MessageToTunnelbroker& 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(MessageToTunnelbroker* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessageToTunnelbroker"; } protected: explicit MessageToTunnelbroker(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { - kSessionIDFieldNumber = 1, - kMessagesToSendFieldNumber = 2, - kProcessedMessagesFieldNumber = 3, - kNewNotifyTokenFieldNumber = 4, + kMessagesToSendFieldNumber = 1, + kProcessedMessagesFieldNumber = 2, + kNewNotifyTokenFieldNumber = 3, }; - // string sessionID = 1; - void clear_sessionid(); - const std::string& sessionid() const; - void set_sessionid(const std::string& value); - void set_sessionid(std::string&& value); - void set_sessionid(const char* value); - void set_sessionid(const char* value, size_t size); - std::string* mutable_sessionid(); - std::string* release_sessionid(); - void set_allocated_sessionid(std::string* sessionid); - private: - const std::string& _internal_sessionid() const; - void _internal_set_sessionid(const std::string& value); - std::string* _internal_mutable_sessionid(); - public: - - // .tunnelbroker.MessagesToSend messagesToSend = 2; + // .tunnelbroker.MessagesToSend messagesToSend = 1; bool has_messagestosend() const; private: bool _internal_has_messagestosend() const; public: void clear_messagestosend(); const ::tunnelbroker::MessagesToSend& messagestosend() const; ::tunnelbroker::MessagesToSend* release_messagestosend(); ::tunnelbroker::MessagesToSend* mutable_messagestosend(); void set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend); private: const ::tunnelbroker::MessagesToSend& _internal_messagestosend() const; ::tunnelbroker::MessagesToSend* _internal_mutable_messagestosend(); public: void unsafe_arena_set_allocated_messagestosend( ::tunnelbroker::MessagesToSend* messagestosend); ::tunnelbroker::MessagesToSend* unsafe_arena_release_messagestosend(); - // .tunnelbroker.ProcessedMessages processedMessages = 3; + // .tunnelbroker.ProcessedMessages processedMessages = 2; bool has_processedmessages() const; private: bool _internal_has_processedmessages() const; public: void clear_processedmessages(); const ::tunnelbroker::ProcessedMessages& processedmessages() const; ::tunnelbroker::ProcessedMessages* release_processedmessages(); ::tunnelbroker::ProcessedMessages* mutable_processedmessages(); void set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages); private: const ::tunnelbroker::ProcessedMessages& _internal_processedmessages() const; ::tunnelbroker::ProcessedMessages* _internal_mutable_processedmessages(); public: void unsafe_arena_set_allocated_processedmessages( ::tunnelbroker::ProcessedMessages* processedmessages); ::tunnelbroker::ProcessedMessages* unsafe_arena_release_processedmessages(); - // string newNotifyToken = 4; + // string newNotifyToken = 3; bool has_newnotifytoken() const; private: bool _internal_has_newnotifytoken() const; public: void clear_newnotifytoken(); const std::string& newnotifytoken() const; void set_newnotifytoken(const std::string& value); void set_newnotifytoken(std::string&& value); void set_newnotifytoken(const char* value); void set_newnotifytoken(const char* value, size_t size); std::string* mutable_newnotifytoken(); std::string* release_newnotifytoken(); void set_allocated_newnotifytoken(std::string* newnotifytoken); private: const std::string& _internal_newnotifytoken() const; void _internal_set_newnotifytoken(const std::string& value); std::string* _internal_mutable_newnotifytoken(); public: void clear_data(); DataCase data_case() const; // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToTunnelbroker) private: class _Internal; void set_has_messagestosend(); void set_has_processedmessages(); void set_has_newnotifytoken(); inline bool has_data() const; inline void clear_has_data(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sessionid_; union DataUnion { constexpr DataUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::tunnelbroker::MessagesToSend* messagestosend_; ::tunnelbroker::ProcessedMessages* processedmessages_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newnotifytoken_; } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessageToClientStruct PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToClientStruct) */ { public: inline MessageToClientStruct() : MessageToClientStruct(nullptr) {} virtual ~MessageToClientStruct(); explicit constexpr MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessageToClientStruct(const MessageToClientStruct& from); MessageToClientStruct(MessageToClientStruct&& from) noexcept : MessageToClientStruct() { *this = ::std::move(from); } inline MessageToClientStruct& operator=(const MessageToClientStruct& from) { CopyFrom(from); return *this; } inline MessageToClientStruct& operator=(MessageToClientStruct&& 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 MessageToClientStruct& default_instance() { return *internal_default_instance(); } static inline const MessageToClientStruct* internal_default_instance() { return reinterpret_cast( &_MessageToClientStruct_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(MessageToClientStruct& a, MessageToClientStruct& b) { a.Swap(&b); } inline void Swap(MessageToClientStruct* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessageToClientStruct* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessageToClientStruct* New() const final { return CreateMaybeMessage(nullptr); } MessageToClientStruct* 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 MessageToClientStruct& from); void MergeFrom(const MessageToClientStruct& 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(MessageToClientStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessageToClientStruct"; } protected: explicit MessageToClientStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBlobHashesFieldNumber = 4, kMessageIDFieldNumber = 1, kFromDeviceIDFieldNumber = 2, kPayloadFieldNumber = 3, }; // repeated string blobHashes = 4; int blobhashes_size() const; private: int _internal_blobhashes_size() const; public: void clear_blobhashes(); const std::string& blobhashes(int index) const; std::string* mutable_blobhashes(int index); void set_blobhashes(int index, const std::string& value); void set_blobhashes(int index, std::string&& value); void set_blobhashes(int index, const char* value); void set_blobhashes(int index, const char* value, size_t size); std::string* add_blobhashes(); void add_blobhashes(const std::string& value); void add_blobhashes(std::string&& value); void add_blobhashes(const char* value); void add_blobhashes(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& blobhashes() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_blobhashes(); private: const std::string& _internal_blobhashes(int index) const; std::string* _internal_add_blobhashes(); public: // string messageID = 1; void clear_messageid(); const std::string& messageid() const; void set_messageid(const std::string& value); void set_messageid(std::string&& value); void set_messageid(const char* value); void set_messageid(const char* value, size_t size); std::string* mutable_messageid(); std::string* release_messageid(); void set_allocated_messageid(std::string* messageid); private: const std::string& _internal_messageid() const; void _internal_set_messageid(const std::string& value); std::string* _internal_mutable_messageid(); public: // string fromDeviceID = 2; void clear_fromdeviceid(); const std::string& fromdeviceid() const; void set_fromdeviceid(const std::string& value); void set_fromdeviceid(std::string&& value); void set_fromdeviceid(const char* value); void set_fromdeviceid(const char* value, size_t size); std::string* mutable_fromdeviceid(); std::string* release_fromdeviceid(); void set_allocated_fromdeviceid(std::string* fromdeviceid); private: const std::string& _internal_fromdeviceid() const; void _internal_set_fromdeviceid(const std::string& value); std::string* _internal_mutable_fromdeviceid(); public: // string payload = 3; void clear_payload(); const std::string& payload() const; void set_payload(const std::string& value); void set_payload(std::string&& value); void set_payload(const char* value); void set_payload(const char* value, size_t size); std::string* mutable_payload(); std::string* release_payload(); void set_allocated_payload(std::string* payload); private: const std::string& _internal_payload() const; void _internal_set_payload(const std::string& value); std::string* _internal_mutable_payload(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToClientStruct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField blobhashes_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fromdeviceid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessagesToDeliver PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessagesToDeliver) */ { public: inline MessagesToDeliver() : MessagesToDeliver(nullptr) {} virtual ~MessagesToDeliver(); explicit constexpr MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessagesToDeliver(const MessagesToDeliver& from); MessagesToDeliver(MessagesToDeliver&& from) noexcept : MessagesToDeliver() { *this = ::std::move(from); } inline MessagesToDeliver& operator=(const MessagesToDeliver& from) { CopyFrom(from); return *this; } inline MessagesToDeliver& operator=(MessagesToDeliver&& 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 MessagesToDeliver& default_instance() { return *internal_default_instance(); } static inline const MessagesToDeliver* internal_default_instance() { return reinterpret_cast( &_MessagesToDeliver_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(MessagesToDeliver& a, MessagesToDeliver& b) { a.Swap(&b); } inline void Swap(MessagesToDeliver* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessagesToDeliver* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessagesToDeliver* New() const final { return CreateMaybeMessage(nullptr); } MessagesToDeliver* 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 MessagesToDeliver& from); void MergeFrom(const MessagesToDeliver& 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(MessagesToDeliver* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessagesToDeliver"; } protected: explicit MessagesToDeliver(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMessagesFieldNumber = 1, }; // repeated .tunnelbroker.MessageToClientStruct messages = 1; int messages_size() const; private: int _internal_messages_size() const; public: void clear_messages(); ::tunnelbroker::MessageToClientStruct* mutable_messages(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >* mutable_messages(); private: const ::tunnelbroker::MessageToClientStruct& _internal_messages(int index) const; ::tunnelbroker::MessageToClientStruct* _internal_add_messages(); public: const ::tunnelbroker::MessageToClientStruct& messages(int index) const; ::tunnelbroker::MessageToClientStruct* add_messages(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >& messages() const; // @@protoc_insertion_point(class_scope:tunnelbroker.MessagesToDeliver) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct > messages_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class MessageToClient PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.MessageToClient) */ { public: inline MessageToClient() : MessageToClient(nullptr) {} virtual ~MessageToClient(); explicit constexpr MessageToClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); MessageToClient(const MessageToClient& from); MessageToClient(MessageToClient&& from) noexcept : MessageToClient() { *this = ::std::move(from); } inline MessageToClient& operator=(const MessageToClient& from) { CopyFrom(from); return *this; } inline MessageToClient& operator=(MessageToClient&& 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 MessageToClient& default_instance() { return *internal_default_instance(); } enum DataCase { kMessagesToDeliver = 1, kProcessedMessages = 2, kNewNotifyTokenRequired = 3, kPing = 4, DATA_NOT_SET = 0, }; static inline const MessageToClient* internal_default_instance() { return reinterpret_cast( &_MessageToClient_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(MessageToClient& a, MessageToClient& b) { a.Swap(&b); } inline void Swap(MessageToClient* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MessageToClient* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MessageToClient* New() const final { return CreateMaybeMessage(nullptr); } MessageToClient* 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 MessageToClient& from); void MergeFrom(const MessageToClient& 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(MessageToClient* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.MessageToClient"; } protected: explicit MessageToClient(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kMessagesToDeliverFieldNumber = 1, kProcessedMessagesFieldNumber = 2, kNewNotifyTokenRequiredFieldNumber = 3, kPingFieldNumber = 4, }; // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; bool has_messagestodeliver() const; private: bool _internal_has_messagestodeliver() const; public: void clear_messagestodeliver(); const ::tunnelbroker::MessagesToDeliver& messagestodeliver() const; ::tunnelbroker::MessagesToDeliver* release_messagestodeliver(); ::tunnelbroker::MessagesToDeliver* mutable_messagestodeliver(); void set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver); private: const ::tunnelbroker::MessagesToDeliver& _internal_messagestodeliver() const; ::tunnelbroker::MessagesToDeliver* _internal_mutable_messagestodeliver(); public: void unsafe_arena_set_allocated_messagestodeliver( ::tunnelbroker::MessagesToDeliver* messagestodeliver); ::tunnelbroker::MessagesToDeliver* unsafe_arena_release_messagestodeliver(); // .tunnelbroker.ProcessedMessages processedMessages = 2; bool has_processedmessages() const; private: bool _internal_has_processedmessages() const; public: void clear_processedmessages(); const ::tunnelbroker::ProcessedMessages& processedmessages() const; ::tunnelbroker::ProcessedMessages* release_processedmessages(); ::tunnelbroker::ProcessedMessages* mutable_processedmessages(); void set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages); private: const ::tunnelbroker::ProcessedMessages& _internal_processedmessages() const; ::tunnelbroker::ProcessedMessages* _internal_mutable_processedmessages(); public: void unsafe_arena_set_allocated_processedmessages( ::tunnelbroker::ProcessedMessages* processedmessages); ::tunnelbroker::ProcessedMessages* unsafe_arena_release_processedmessages(); // .google.protobuf.Empty newNotifyTokenRequired = 3; bool has_newnotifytokenrequired() const; private: bool _internal_has_newnotifytokenrequired() const; public: void clear_newnotifytokenrequired(); const PROTOBUF_NAMESPACE_ID::Empty& newnotifytokenrequired() const; PROTOBUF_NAMESPACE_ID::Empty* release_newnotifytokenrequired(); PROTOBUF_NAMESPACE_ID::Empty* mutable_newnotifytokenrequired(); void set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired); private: const PROTOBUF_NAMESPACE_ID::Empty& _internal_newnotifytokenrequired() const; PROTOBUF_NAMESPACE_ID::Empty* _internal_mutable_newnotifytokenrequired(); public: void unsafe_arena_set_allocated_newnotifytokenrequired( PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired); PROTOBUF_NAMESPACE_ID::Empty* unsafe_arena_release_newnotifytokenrequired(); // .google.protobuf.Empty ping = 4; bool has_ping() const; private: bool _internal_has_ping() const; public: void clear_ping(); const PROTOBUF_NAMESPACE_ID::Empty& ping() const; PROTOBUF_NAMESPACE_ID::Empty* release_ping(); PROTOBUF_NAMESPACE_ID::Empty* mutable_ping(); void set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping); private: const PROTOBUF_NAMESPACE_ID::Empty& _internal_ping() const; PROTOBUF_NAMESPACE_ID::Empty* _internal_mutable_ping(); public: void unsafe_arena_set_allocated_ping( PROTOBUF_NAMESPACE_ID::Empty* ping); PROTOBUF_NAMESPACE_ID::Empty* unsafe_arena_release_ping(); void clear_data(); DataCase data_case() const; // @@protoc_insertion_point(class_scope:tunnelbroker.MessageToClient) private: class _Internal; void set_has_messagestodeliver(); void set_has_processedmessages(); void set_has_newnotifytokenrequired(); void set_has_ping(); 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_; ::tunnelbroker::MessagesToDeliver* messagestodeliver_; ::tunnelbroker::ProcessedMessages* processedmessages_; PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired_; PROTOBUF_NAMESPACE_ID::Empty* ping_; } data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class CheckRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckRequest) */ { public: inline CheckRequest() : CheckRequest(nullptr) {} virtual ~CheckRequest(); explicit constexpr CheckRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CheckRequest(const CheckRequest& from); CheckRequest(CheckRequest&& from) noexcept : CheckRequest() { *this = ::std::move(from); } inline CheckRequest& operator=(const CheckRequest& from) { CopyFrom(from); return *this; } inline CheckRequest& operator=(CheckRequest&& 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 CheckRequest& default_instance() { return *internal_default_instance(); } static inline const CheckRequest* internal_default_instance() { return reinterpret_cast( &_CheckRequest_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(CheckRequest& a, CheckRequest& b) { a.Swap(&b); } inline void Swap(CheckRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CheckRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline CheckRequest* New() const final { return CreateMaybeMessage(nullptr); } CheckRequest* 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 CheckRequest& from); void MergeFrom(const CheckRequest& 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(CheckRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.CheckRequest"; } protected: explicit CheckRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kUserIdFieldNumber = 1, kDeviceTokenFieldNumber = 2, }; // string userId = 1; void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); void set_userid(std::string&& value); void set_userid(const char* value); void set_userid(const char* value, size_t size); std::string* mutable_userid(); std::string* release_userid(); void set_allocated_userid(std::string* userid); private: const std::string& _internal_userid() const; void _internal_set_userid(const std::string& value); std::string* _internal_mutable_userid(); public: // string deviceToken = 2; void clear_devicetoken(); const std::string& devicetoken() const; void set_devicetoken(const std::string& value); void set_devicetoken(std::string&& value); void set_devicetoken(const char* value); void set_devicetoken(const char* value, size_t size); std::string* mutable_devicetoken(); std::string* release_devicetoken(); void set_allocated_devicetoken(std::string* devicetoken); private: const std::string& _internal_devicetoken() const; void _internal_set_devicetoken(const std::string& value); std::string* _internal_mutable_devicetoken(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.CheckRequest) 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 devicetoken_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class CheckResponse PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.CheckResponse) */ { public: inline CheckResponse() : CheckResponse(nullptr) {} virtual ~CheckResponse(); explicit constexpr CheckResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CheckResponse(const CheckResponse& from); CheckResponse(CheckResponse&& from) noexcept : CheckResponse() { *this = ::std::move(from); } inline CheckResponse& operator=(const CheckResponse& from) { CopyFrom(from); return *this; } inline CheckResponse& operator=(CheckResponse&& 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 CheckResponse& default_instance() { return *internal_default_instance(); } static inline const CheckResponse* internal_default_instance() { return reinterpret_cast( &_CheckResponse_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(CheckResponse& a, CheckResponse& b) { a.Swap(&b); } inline void Swap(CheckResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CheckResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline CheckResponse* New() const final { return CreateMaybeMessage(nullptr); } CheckResponse* 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 CheckResponse& from); void MergeFrom(const CheckResponse& 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(CheckResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.CheckResponse"; } protected: explicit CheckResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kCheckResponseTypeFieldNumber = 1, }; // .tunnelbroker.CheckResponseType checkResponseType = 1; void clear_checkresponsetype(); ::tunnelbroker::CheckResponseType checkresponsetype() const; void set_checkresponsetype(::tunnelbroker::CheckResponseType value); private: ::tunnelbroker::CheckResponseType _internal_checkresponsetype() const; void _internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value); public: // @@protoc_insertion_point(class_scope:tunnelbroker.CheckResponse) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; int checkresponsetype_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class NewPrimaryRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryRequest) */ { public: inline NewPrimaryRequest() : NewPrimaryRequest(nullptr) {} virtual ~NewPrimaryRequest(); explicit constexpr NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NewPrimaryRequest(const NewPrimaryRequest& from); NewPrimaryRequest(NewPrimaryRequest&& from) noexcept : NewPrimaryRequest() { *this = ::std::move(from); } inline NewPrimaryRequest& operator=(const NewPrimaryRequest& from) { CopyFrom(from); return *this; } inline NewPrimaryRequest& operator=(NewPrimaryRequest&& 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 NewPrimaryRequest& default_instance() { return *internal_default_instance(); } static inline const NewPrimaryRequest* internal_default_instance() { return reinterpret_cast( &_NewPrimaryRequest_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(NewPrimaryRequest& a, NewPrimaryRequest& b) { a.Swap(&b); } inline void Swap(NewPrimaryRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NewPrimaryRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline NewPrimaryRequest* New() const final { return CreateMaybeMessage(nullptr); } NewPrimaryRequest* 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 NewPrimaryRequest& from); void MergeFrom(const NewPrimaryRequest& 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(NewPrimaryRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.NewPrimaryRequest"; } protected: explicit NewPrimaryRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kUserIdFieldNumber = 1, kDeviceTokenFieldNumber = 2, }; // string userId = 1; void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); void set_userid(std::string&& value); void set_userid(const char* value); void set_userid(const char* value, size_t size); std::string* mutable_userid(); std::string* release_userid(); void set_allocated_userid(std::string* userid); private: const std::string& _internal_userid() const; void _internal_set_userid(const std::string& value); std::string* _internal_mutable_userid(); public: // string deviceToken = 2; void clear_devicetoken(); const std::string& devicetoken() const; void set_devicetoken(const std::string& value); void set_devicetoken(std::string&& value); void set_devicetoken(const char* value); void set_devicetoken(const char* value, size_t size); std::string* mutable_devicetoken(); std::string* release_devicetoken(); void set_allocated_devicetoken(std::string* devicetoken); private: const std::string& _internal_devicetoken() const; void _internal_set_devicetoken(const std::string& value); std::string* _internal_mutable_devicetoken(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryRequest) 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 devicetoken_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class NewPrimaryResponse PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.NewPrimaryResponse) */ { public: inline NewPrimaryResponse() : NewPrimaryResponse(nullptr) {} virtual ~NewPrimaryResponse(); explicit constexpr NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NewPrimaryResponse(const NewPrimaryResponse& from); NewPrimaryResponse(NewPrimaryResponse&& from) noexcept : NewPrimaryResponse() { *this = ::std::move(from); } inline NewPrimaryResponse& operator=(const NewPrimaryResponse& from) { CopyFrom(from); return *this; } inline NewPrimaryResponse& operator=(NewPrimaryResponse&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } 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 NewPrimaryResponse& default_instance() { return *internal_default_instance(); } static inline const NewPrimaryResponse* internal_default_instance() { return reinterpret_cast( &_NewPrimaryResponse_default_instance_); } static constexpr int kIndexInFileMessages = 18; friend void swap(NewPrimaryResponse& a, NewPrimaryResponse& b) { a.Swap(&b); } inline void Swap(NewPrimaryResponse* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NewPrimaryResponse* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline NewPrimaryResponse* New() const final { return CreateMaybeMessage(nullptr); } NewPrimaryResponse* 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 NewPrimaryResponse& from); void MergeFrom(const NewPrimaryResponse& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NewPrimaryResponse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.NewPrimaryResponse"; } protected: explicit NewPrimaryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSuccessFieldNumber = 1, }; // bool success = 1; void clear_success(); bool success() const; void set_success(bool value); private: bool _internal_success() const; void _internal_set_success(bool value); public: // @@protoc_insertion_point(class_scope:tunnelbroker.NewPrimaryResponse) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; bool success_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // ------------------------------------------------------------------- class PongRequest PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tunnelbroker.PongRequest) */ { public: inline PongRequest() : PongRequest(nullptr) {} virtual ~PongRequest(); explicit constexpr PongRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); PongRequest(const PongRequest& from); PongRequest(PongRequest&& from) noexcept : PongRequest() { *this = ::std::move(from); } inline PongRequest& operator=(const PongRequest& from) { CopyFrom(from); return *this; } inline PongRequest& operator=(PongRequest&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const PongRequest& default_instance() { return *internal_default_instance(); } static inline const PongRequest* internal_default_instance() { return reinterpret_cast( &_PongRequest_default_instance_); } static constexpr int kIndexInFileMessages = 19; friend void swap(PongRequest& a, PongRequest& b) { a.Swap(&b); } inline void Swap(PongRequest* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PongRequest* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline PongRequest* New() const final { return CreateMaybeMessage(nullptr); } PongRequest* 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 PongRequest& from); void MergeFrom(const PongRequest& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PongRequest* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "tunnelbroker.PongRequest"; } protected: explicit PongRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { return ::descriptor_table_tunnelbroker_2eproto_metadata_getter(kIndexInFileMessages); } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kUserIdFieldNumber = 1, kDeviceTokenFieldNumber = 2, }; // string userId = 1; void clear_userid(); const std::string& userid() const; void set_userid(const std::string& value); void set_userid(std::string&& value); void set_userid(const char* value); void set_userid(const char* value, size_t size); std::string* mutable_userid(); std::string* release_userid(); void set_allocated_userid(std::string* userid); private: const std::string& _internal_userid() const; void _internal_set_userid(const std::string& value); std::string* _internal_mutable_userid(); public: // string deviceToken = 2; void clear_devicetoken(); const std::string& devicetoken() const; void set_devicetoken(const std::string& value); void set_devicetoken(std::string&& value); void set_devicetoken(const char* value); void set_devicetoken(const char* value, size_t size); std::string* mutable_devicetoken(); std::string* release_devicetoken(); void set_allocated_devicetoken(std::string* devicetoken); private: const std::string& _internal_devicetoken() const; void _internal_set_devicetoken(const std::string& value); std::string* _internal_mutable_devicetoken(); public: // @@protoc_insertion_point(class_scope:tunnelbroker.PongRequest) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicetoken_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_tunnelbroker_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // SessionSignatureRequest // string deviceID = 1; inline void SessionSignatureRequest::clear_deviceid() { deviceid_.ClearToEmpty(); } inline const std::string& SessionSignatureRequest::deviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureRequest.deviceID) return _internal_deviceid(); } inline void SessionSignatureRequest::set_deviceid(const std::string& value) { _internal_set_deviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureRequest.deviceID) } inline std::string* SessionSignatureRequest::mutable_deviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureRequest.deviceID) return _internal_mutable_deviceid(); } inline const std::string& SessionSignatureRequest::_internal_deviceid() const { return deviceid_.Get(); } inline void SessionSignatureRequest::_internal_set_deviceid(const std::string& value) { deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void SessionSignatureRequest::set_deviceid(std::string&& value) { deviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureRequest.deviceID) } inline void SessionSignatureRequest::set_deviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureRequest.deviceID) } inline void SessionSignatureRequest::set_deviceid(const char* value, size_t size) { deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureRequest.deviceID) } inline std::string* SessionSignatureRequest::_internal_mutable_deviceid() { return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* SessionSignatureRequest::release_deviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureRequest.deviceID) return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void SessionSignatureRequest::set_allocated_deviceid(std::string* deviceid) { if (deviceid != nullptr) { } else { } deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureRequest.deviceID) } // ------------------------------------------------------------------- // SessionSignatureResponse // string toSign = 1; inline void SessionSignatureResponse::clear_tosign() { tosign_.ClearToEmpty(); } inline const std::string& SessionSignatureResponse::tosign() const { // @@protoc_insertion_point(field_get:tunnelbroker.SessionSignatureResponse.toSign) return _internal_tosign(); } inline void SessionSignatureResponse::set_tosign(const std::string& value) { _internal_set_tosign(value); // @@protoc_insertion_point(field_set:tunnelbroker.SessionSignatureResponse.toSign) } inline std::string* SessionSignatureResponse::mutable_tosign() { // @@protoc_insertion_point(field_mutable:tunnelbroker.SessionSignatureResponse.toSign) return _internal_mutable_tosign(); } inline const std::string& SessionSignatureResponse::_internal_tosign() const { return tosign_.Get(); } inline void SessionSignatureResponse::_internal_set_tosign(const std::string& value) { tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void SessionSignatureResponse::set_tosign(std::string&& value) { tosign_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SessionSignatureResponse.toSign) } inline void SessionSignatureResponse::set_tosign(const char* value) { GOOGLE_DCHECK(value != nullptr); tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.SessionSignatureResponse.toSign) } inline void SessionSignatureResponse::set_tosign(const char* value, size_t size) { tosign_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SessionSignatureResponse.toSign) } inline std::string* SessionSignatureResponse::_internal_mutable_tosign() { return tosign_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* SessionSignatureResponse::release_tosign() { // @@protoc_insertion_point(field_release:tunnelbroker.SessionSignatureResponse.toSign) return tosign_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void SessionSignatureResponse::set_allocated_tosign(std::string* tosign) { if (tosign != nullptr) { } else { } tosign_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tosign, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SessionSignatureResponse.toSign) } // ------------------------------------------------------------------- // NewSessionRequest // string deviceID = 1; inline void NewSessionRequest::clear_deviceid() { deviceid_.ClearToEmpty(); } inline const std::string& NewSessionRequest::deviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceID) return _internal_deviceid(); } inline void NewSessionRequest::set_deviceid(const std::string& value) { _internal_set_deviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceID) } inline std::string* NewSessionRequest::mutable_deviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceID) return _internal_mutable_deviceid(); } inline const std::string& NewSessionRequest::_internal_deviceid() const { return deviceid_.Get(); } inline void NewSessionRequest::_internal_set_deviceid(const std::string& value) { deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_deviceid(std::string&& value) { deviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceID) } inline void NewSessionRequest::set_deviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceID) } inline void NewSessionRequest::set_deviceid(const char* value, size_t size) { deviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceID) } inline std::string* NewSessionRequest::_internal_mutable_deviceid() { return deviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_deviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceID) return deviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_deviceid(std::string* deviceid) { if (deviceid != nullptr) { } else { } deviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceID) } // string publicKey = 2; inline void NewSessionRequest::clear_publickey() { publickey_.ClearToEmpty(); } inline const std::string& NewSessionRequest::publickey() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.publicKey) return _internal_publickey(); } inline void NewSessionRequest::set_publickey(const std::string& value) { _internal_set_publickey(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.publicKey) } inline std::string* NewSessionRequest::mutable_publickey() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.publicKey) return _internal_mutable_publickey(); } inline const std::string& NewSessionRequest::_internal_publickey() const { return publickey_.Get(); } inline void NewSessionRequest::_internal_set_publickey(const std::string& value) { publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_publickey(std::string&& value) { publickey_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.publicKey) } inline void NewSessionRequest::set_publickey(const char* value) { GOOGLE_DCHECK(value != nullptr); publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.publicKey) } inline void NewSessionRequest::set_publickey(const char* value, size_t size) { publickey_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.publicKey) } inline std::string* NewSessionRequest::_internal_mutable_publickey() { return publickey_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_publickey() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.publicKey) return publickey_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_publickey(std::string* publickey) { if (publickey != nullptr) { } else { } publickey_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publickey, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.publicKey) } // string signature = 3; inline void NewSessionRequest::clear_signature() { signature_.ClearToEmpty(); } inline const std::string& NewSessionRequest::signature() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.signature) return _internal_signature(); } inline void NewSessionRequest::set_signature(const std::string& value) { _internal_set_signature(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.signature) } inline std::string* NewSessionRequest::mutable_signature() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.signature) return _internal_mutable_signature(); } inline const std::string& NewSessionRequest::_internal_signature() const { return signature_.Get(); } inline void NewSessionRequest::_internal_set_signature(const std::string& value) { signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_signature(std::string&& value) { signature_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.signature) } inline void NewSessionRequest::set_signature(const char* value) { GOOGLE_DCHECK(value != nullptr); signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.signature) } inline void NewSessionRequest::set_signature(const char* value, size_t size) { signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.signature) } inline std::string* NewSessionRequest::_internal_mutable_signature() { return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_signature() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.signature) return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_signature(std::string* signature) { if (signature != nullptr) { } else { } signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.signature) } // string notifyToken = 4; inline bool NewSessionRequest::_internal_has_notifytoken() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool NewSessionRequest::has_notifytoken() const { return _internal_has_notifytoken(); } inline void NewSessionRequest::clear_notifytoken() { notifytoken_.ClearToEmpty(); _has_bits_[0] &= ~0x00000001u; } inline const std::string& NewSessionRequest::notifytoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.notifyToken) return _internal_notifytoken(); } inline void NewSessionRequest::set_notifytoken(const std::string& value) { _internal_set_notifytoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.notifyToken) } inline std::string* NewSessionRequest::mutable_notifytoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.notifyToken) return _internal_mutable_notifytoken(); } inline const std::string& NewSessionRequest::_internal_notifytoken() const { return notifytoken_.Get(); } inline void NewSessionRequest::_internal_set_notifytoken(const std::string& value) { _has_bits_[0] |= 0x00000001u; notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_notifytoken(std::string&& value) { _has_bits_[0] |= 0x00000001u; notifytoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.notifyToken) } inline void NewSessionRequest::set_notifytoken(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.notifyToken) } inline void NewSessionRequest::set_notifytoken(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; notifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.notifyToken) } inline std::string* NewSessionRequest::_internal_mutable_notifytoken() { _has_bits_[0] |= 0x00000001u; return notifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_notifytoken() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.notifyToken) if (!_internal_has_notifytoken()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return notifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_notifytoken(std::string* notifytoken) { if (notifytoken != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } notifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notifytoken, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.notifyToken) } // .tunnelbroker.NewSessionRequest.DeviceTypes deviceType = 5; inline void NewSessionRequest::clear_devicetype() { devicetype_ = 0; } inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::_internal_devicetype() const { return static_cast< ::tunnelbroker::NewSessionRequest_DeviceTypes >(devicetype_); } inline ::tunnelbroker::NewSessionRequest_DeviceTypes NewSessionRequest::devicetype() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceType) return _internal_devicetype(); } inline void NewSessionRequest::_internal_set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) { devicetype_ = value; } inline void NewSessionRequest::set_devicetype(::tunnelbroker::NewSessionRequest_DeviceTypes value) { _internal_set_devicetype(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceType) } // string deviceAppVersion = 6; inline void NewSessionRequest::clear_deviceappversion() { deviceappversion_.ClearToEmpty(); } inline const std::string& NewSessionRequest::deviceappversion() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceAppVersion) return _internal_deviceappversion(); } inline void NewSessionRequest::set_deviceappversion(const std::string& value) { _internal_set_deviceappversion(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceAppVersion) } inline std::string* NewSessionRequest::mutable_deviceappversion() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceAppVersion) return _internal_mutable_deviceappversion(); } inline const std::string& NewSessionRequest::_internal_deviceappversion() const { return deviceappversion_.Get(); } inline void NewSessionRequest::_internal_set_deviceappversion(const std::string& value) { deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_deviceappversion(std::string&& value) { deviceappversion_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceAppVersion) } inline void NewSessionRequest::set_deviceappversion(const char* value) { GOOGLE_DCHECK(value != nullptr); deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceAppVersion) } inline void NewSessionRequest::set_deviceappversion(const char* value, size_t size) { deviceappversion_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceAppVersion) } inline std::string* NewSessionRequest::_internal_mutable_deviceappversion() { return deviceappversion_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_deviceappversion() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceAppVersion) return deviceappversion_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_deviceappversion(std::string* deviceappversion) { if (deviceappversion != nullptr) { } else { } deviceappversion_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceappversion, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceAppVersion) } // string deviceOS = 7; inline void NewSessionRequest::clear_deviceos() { deviceos_.ClearToEmpty(); } inline const std::string& NewSessionRequest::deviceos() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionRequest.deviceOS) return _internal_deviceos(); } inline void NewSessionRequest::set_deviceos(const std::string& value) { _internal_set_deviceos(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionRequest.deviceOS) } inline std::string* NewSessionRequest::mutable_deviceos() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionRequest.deviceOS) return _internal_mutable_deviceos(); } inline const std::string& NewSessionRequest::_internal_deviceos() const { return deviceos_.Get(); } inline void NewSessionRequest::_internal_set_deviceos(const std::string& value) { deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionRequest::set_deviceos(std::string&& value) { deviceos_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionRequest.deviceOS) } inline void NewSessionRequest::set_deviceos(const char* value) { GOOGLE_DCHECK(value != nullptr); deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionRequest.deviceOS) } inline void NewSessionRequest::set_deviceos(const char* value, size_t size) { deviceos_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionRequest.deviceOS) } inline std::string* NewSessionRequest::_internal_mutable_deviceos() { return deviceos_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionRequest::release_deviceos() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionRequest.deviceOS) return deviceos_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionRequest::set_allocated_deviceos(std::string* deviceos) { if (deviceos != nullptr) { } else { } deviceos_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deviceos, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionRequest.deviceOS) } // ------------------------------------------------------------------- // NewSessionResponse // string sessionID = 1; inline void NewSessionResponse::clear_sessionid() { sessionid_.ClearToEmpty(); } inline const std::string& NewSessionResponse::sessionid() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewSessionResponse.sessionID) return _internal_sessionid(); } inline void NewSessionResponse::set_sessionid(const std::string& value) { _internal_set_sessionid(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewSessionResponse.sessionID) } inline std::string* NewSessionResponse::mutable_sessionid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewSessionResponse.sessionID) return _internal_mutable_sessionid(); } inline const std::string& NewSessionResponse::_internal_sessionid() const { return sessionid_.Get(); } inline void NewSessionResponse::_internal_set_sessionid(const std::string& value) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewSessionResponse::set_sessionid(std::string&& value) { sessionid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewSessionResponse.sessionID) } inline void NewSessionResponse::set_sessionid(const char* value) { GOOGLE_DCHECK(value != nullptr); sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewSessionResponse.sessionID) } inline void NewSessionResponse::set_sessionid(const char* value, size_t size) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewSessionResponse.sessionID) } inline std::string* NewSessionResponse::_internal_mutable_sessionid() { return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewSessionResponse::release_sessionid() { // @@protoc_insertion_point(field_release:tunnelbroker.NewSessionResponse.sessionID) return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewSessionResponse::set_allocated_sessionid(std::string* sessionid) { if (sessionid != nullptr) { } else { } sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewSessionResponse.sessionID) } // ------------------------------------------------------------------- // SendRequest // string sessionID = 1; inline void SendRequest::clear_sessionid() { sessionid_.ClearToEmpty(); } inline const std::string& SendRequest::sessionid() const { // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.sessionID) return _internal_sessionid(); } inline void SendRequest::set_sessionid(const std::string& value) { _internal_set_sessionid(value); // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.sessionID) } inline std::string* SendRequest::mutable_sessionid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.sessionID) return _internal_mutable_sessionid(); } inline const std::string& SendRequest::_internal_sessionid() const { return sessionid_.Get(); } inline void SendRequest::_internal_set_sessionid(const std::string& value) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void SendRequest::set_sessionid(std::string&& value) { sessionid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.sessionID) } inline void SendRequest::set_sessionid(const char* value) { GOOGLE_DCHECK(value != nullptr); sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.sessionID) } inline void SendRequest::set_sessionid(const char* value, size_t size) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.sessionID) } inline std::string* SendRequest::_internal_mutable_sessionid() { return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* SendRequest::release_sessionid() { // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.sessionID) return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void SendRequest::set_allocated_sessionid(std::string* sessionid) { if (sessionid != nullptr) { } else { } sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.sessionID) } // string toDeviceID = 2; inline void SendRequest::clear_todeviceid() { todeviceid_.ClearToEmpty(); } inline const std::string& SendRequest::todeviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.toDeviceID) return _internal_todeviceid(); } inline void SendRequest::set_todeviceid(const std::string& value) { _internal_set_todeviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.toDeviceID) } inline std::string* SendRequest::mutable_todeviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.toDeviceID) return _internal_mutable_todeviceid(); } inline const std::string& SendRequest::_internal_todeviceid() const { return todeviceid_.Get(); } inline void SendRequest::_internal_set_todeviceid(const std::string& value) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void SendRequest::set_todeviceid(std::string&& value) { todeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.toDeviceID) } inline void SendRequest::set_todeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.toDeviceID) } inline void SendRequest::set_todeviceid(const char* value, size_t size) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.toDeviceID) } inline std::string* SendRequest::_internal_mutable_todeviceid() { return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* SendRequest::release_todeviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.toDeviceID) return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void SendRequest::set_allocated_todeviceid(std::string* todeviceid) { if (todeviceid != nullptr) { } else { } todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.toDeviceID) } // bytes payload = 3; inline void SendRequest::clear_payload() { payload_.ClearToEmpty(); } inline const std::string& SendRequest::payload() const { // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.payload) return _internal_payload(); } inline void SendRequest::set_payload(const std::string& value) { _internal_set_payload(value); // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.payload) } inline std::string* SendRequest::mutable_payload() { // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.payload) return _internal_mutable_payload(); } inline const std::string& SendRequest::_internal_payload() const { return payload_.Get(); } inline void SendRequest::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void SendRequest::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.SendRequest.payload) } inline void SendRequest::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.payload) } inline void SendRequest::set_payload(const void* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.payload) } inline std::string* SendRequest::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* SendRequest::release_payload() { // @@protoc_insertion_point(field_release:tunnelbroker.SendRequest.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void SendRequest::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.SendRequest.payload) } // repeated string blobHashes = 4; inline int SendRequest::_internal_blobhashes_size() const { return blobhashes_.size(); } inline int SendRequest::blobhashes_size() const { return _internal_blobhashes_size(); } inline void SendRequest::clear_blobhashes() { blobhashes_.Clear(); } inline std::string* SendRequest::add_blobhashes() { // @@protoc_insertion_point(field_add_mutable:tunnelbroker.SendRequest.blobHashes) return _internal_add_blobhashes(); } inline const std::string& SendRequest::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } inline const std::string& SendRequest::blobhashes(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.SendRequest.blobHashes) return _internal_blobhashes(index); } inline std::string* SendRequest::mutable_blobhashes(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.SendRequest.blobHashes) return blobhashes_.Mutable(index); } inline void SendRequest::set_blobhashes(int index, const std::string& value) { // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes) blobhashes_.Mutable(index)->assign(value); } inline void SendRequest::set_blobhashes(int index, std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.SendRequest.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } inline void SendRequest::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:tunnelbroker.SendRequest.blobHashes) } inline void SendRequest::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.SendRequest.blobHashes) } inline std::string* SendRequest::_internal_add_blobhashes() { return blobhashes_.Add(); } inline void SendRequest::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes) } inline void SendRequest::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); // @@protoc_insertion_point(field_add:tunnelbroker.SendRequest.blobHashes) } inline void SendRequest::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:tunnelbroker.SendRequest.blobHashes) } inline void SendRequest::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:tunnelbroker.SendRequest.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& SendRequest::blobhashes() const { // @@protoc_insertion_point(field_list:tunnelbroker.SendRequest.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* SendRequest::mutable_blobhashes() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.SendRequest.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- // GetRequest // string sessionID = 1; inline void GetRequest::clear_sessionid() { sessionid_.ClearToEmpty(); } inline const std::string& GetRequest::sessionid() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.sessionID) return _internal_sessionid(); } inline void GetRequest::set_sessionid(const std::string& value) { _internal_set_sessionid(value); // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.sessionID) } inline std::string* GetRequest::mutable_sessionid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.sessionID) return _internal_mutable_sessionid(); } inline const std::string& GetRequest::_internal_sessionid() const { return sessionid_.Get(); } inline void GetRequest::_internal_set_sessionid(const std::string& value) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void GetRequest::set_sessionid(std::string&& value) { sessionid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.sessionID) } inline void GetRequest::set_sessionid(const char* value) { GOOGLE_DCHECK(value != nullptr); sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.sessionID) } inline void GetRequest::set_sessionid(const char* value, size_t size) { sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.sessionID) } inline std::string* GetRequest::_internal_mutable_sessionid() { return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* GetRequest::release_sessionid() { // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.sessionID) return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void GetRequest::set_allocated_sessionid(std::string* sessionid) { if (sessionid != nullptr) { } else { } sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.sessionID) } // string newNotifyToken = 2; inline bool GetRequest::_internal_has_newnotifytoken() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool GetRequest::has_newnotifytoken() const { return _internal_has_newnotifytoken(); } inline void GetRequest::clear_newnotifytoken() { newnotifytoken_.ClearToEmpty(); _has_bits_[0] &= ~0x00000001u; } inline const std::string& GetRequest::newnotifytoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetRequest.newNotifyToken) return _internal_newnotifytoken(); } inline void GetRequest::set_newnotifytoken(const std::string& value) { _internal_set_newnotifytoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.GetRequest.newNotifyToken) } inline std::string* GetRequest::mutable_newnotifytoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetRequest.newNotifyToken) return _internal_mutable_newnotifytoken(); } inline const std::string& GetRequest::_internal_newnotifytoken() const { return newnotifytoken_.Get(); } inline void GetRequest::_internal_set_newnotifytoken(const std::string& value) { _has_bits_[0] |= 0x00000001u; newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void GetRequest::set_newnotifytoken(std::string&& value) { _has_bits_[0] |= 0x00000001u; newnotifytoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetRequest.newNotifyToken) } inline void GetRequest::set_newnotifytoken(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.GetRequest.newNotifyToken) } inline void GetRequest::set_newnotifytoken(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetRequest.newNotifyToken) } inline std::string* GetRequest::_internal_mutable_newnotifytoken() { _has_bits_[0] |= 0x00000001u; return newnotifytoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* GetRequest::release_newnotifytoken() { // @@protoc_insertion_point(field_release:tunnelbroker.GetRequest.newNotifyToken) if (!_internal_has_newnotifytoken()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return newnotifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void GetRequest::set_allocated_newnotifytoken(std::string* newnotifytoken) { if (newnotifytoken != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } newnotifytoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), newnotifytoken, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetRequest.newNotifyToken) } // ------------------------------------------------------------------- // GetResponseMessage // string fromDeviceID = 1; inline void GetResponseMessage::clear_fromdeviceid() { fromdeviceid_.ClearToEmpty(); } inline const std::string& GetResponseMessage::fromdeviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponseMessage.fromDeviceID) return _internal_fromdeviceid(); } inline void GetResponseMessage::set_fromdeviceid(const std::string& value) { _internal_set_fromdeviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.GetResponseMessage.fromDeviceID) } inline std::string* GetResponseMessage::mutable_fromdeviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponseMessage.fromDeviceID) return _internal_mutable_fromdeviceid(); } inline const std::string& GetResponseMessage::_internal_fromdeviceid() const { return fromdeviceid_.Get(); } inline void GetResponseMessage::_internal_set_fromdeviceid(const std::string& value) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void GetResponseMessage::set_fromdeviceid(std::string&& value) { fromdeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponseMessage.fromDeviceID) } inline void GetResponseMessage::set_fromdeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponseMessage.fromDeviceID) } inline void GetResponseMessage::set_fromdeviceid(const char* value, size_t size) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponseMessage.fromDeviceID) } inline std::string* GetResponseMessage::_internal_mutable_fromdeviceid() { return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* GetResponseMessage::release_fromdeviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.GetResponseMessage.fromDeviceID) return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void GetResponseMessage::set_allocated_fromdeviceid(std::string* fromdeviceid) { if (fromdeviceid != nullptr) { } else { } fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponseMessage.fromDeviceID) } // bytes payload = 2; inline void GetResponseMessage::clear_payload() { payload_.ClearToEmpty(); } inline const std::string& GetResponseMessage::payload() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponseMessage.payload) return _internal_payload(); } inline void GetResponseMessage::set_payload(const std::string& value) { _internal_set_payload(value); // @@protoc_insertion_point(field_set:tunnelbroker.GetResponseMessage.payload) } inline std::string* GetResponseMessage::mutable_payload() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponseMessage.payload) return _internal_mutable_payload(); } inline const std::string& GetResponseMessage::_internal_payload() const { return payload_.Get(); } inline void GetResponseMessage::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void GetResponseMessage::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.GetResponseMessage.payload) } inline void GetResponseMessage::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponseMessage.payload) } inline void GetResponseMessage::set_payload(const void* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponseMessage.payload) } inline std::string* GetResponseMessage::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* GetResponseMessage::release_payload() { // @@protoc_insertion_point(field_release:tunnelbroker.GetResponseMessage.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void GetResponseMessage::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.GetResponseMessage.payload) } // repeated string blobHashes = 3; inline int GetResponseMessage::_internal_blobhashes_size() const { return blobhashes_.size(); } inline int GetResponseMessage::blobhashes_size() const { return _internal_blobhashes_size(); } inline void GetResponseMessage::clear_blobhashes() { blobhashes_.Clear(); } inline std::string* GetResponseMessage::add_blobhashes() { // @@protoc_insertion_point(field_add_mutable:tunnelbroker.GetResponseMessage.blobHashes) return _internal_add_blobhashes(); } inline const std::string& GetResponseMessage::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } inline const std::string& GetResponseMessage::blobhashes(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponseMessage.blobHashes) return _internal_blobhashes(index); } inline std::string* GetResponseMessage::mutable_blobhashes(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponseMessage.blobHashes) return blobhashes_.Mutable(index); } inline void GetResponseMessage::set_blobhashes(int index, const std::string& value) { // @@protoc_insertion_point(field_set:tunnelbroker.GetResponseMessage.blobHashes) blobhashes_.Mutable(index)->assign(value); } inline void GetResponseMessage::set_blobhashes(int index, std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.GetResponseMessage.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } inline void GetResponseMessage::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:tunnelbroker.GetResponseMessage.blobHashes) } inline void GetResponseMessage::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.GetResponseMessage.blobHashes) } inline std::string* GetResponseMessage::_internal_add_blobhashes() { return blobhashes_.Add(); } inline void GetResponseMessage::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.GetResponseMessage.blobHashes) } inline void GetResponseMessage::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); // @@protoc_insertion_point(field_add:tunnelbroker.GetResponseMessage.blobHashes) } inline void GetResponseMessage::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:tunnelbroker.GetResponseMessage.blobHashes) } inline void GetResponseMessage::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:tunnelbroker.GetResponseMessage.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& GetResponseMessage::blobhashes() const { // @@protoc_insertion_point(field_list:tunnelbroker.GetResponseMessage.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* GetResponseMessage::mutable_blobhashes() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.GetResponseMessage.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- // GetResponse // .tunnelbroker.GetResponseMessage responseMessage = 1; inline bool GetResponse::_internal_has_responsemessage() const { return data_case() == kResponseMessage; } inline bool GetResponse::has_responsemessage() const { return _internal_has_responsemessage(); } inline void GetResponse::set_has_responsemessage() { _oneof_case_[0] = kResponseMessage; } inline void GetResponse::clear_responsemessage() { if (_internal_has_responsemessage()) { if (GetArena() == nullptr) { delete data_.responsemessage_; } clear_has_data(); } } inline ::tunnelbroker::GetResponseMessage* GetResponse::release_responsemessage() { // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.responseMessage) if (_internal_has_responsemessage()) { clear_has_data(); ::tunnelbroker::GetResponseMessage* temp = data_.responsemessage_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.responsemessage_ = nullptr; return temp; } else { return nullptr; } } inline const ::tunnelbroker::GetResponseMessage& GetResponse::_internal_responsemessage() const { return _internal_has_responsemessage() ? *data_.responsemessage_ : reinterpret_cast< ::tunnelbroker::GetResponseMessage&>(::tunnelbroker::_GetResponseMessage_default_instance_); } inline const ::tunnelbroker::GetResponseMessage& GetResponse::responsemessage() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.responseMessage) return _internal_responsemessage(); } inline ::tunnelbroker::GetResponseMessage* GetResponse::unsafe_arena_release_responsemessage() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.GetResponse.responseMessage) if (_internal_has_responsemessage()) { clear_has_data(); ::tunnelbroker::GetResponseMessage* temp = data_.responsemessage_; data_.responsemessage_ = nullptr; return temp; } else { return nullptr; } } inline void GetResponse::unsafe_arena_set_allocated_responsemessage(::tunnelbroker::GetResponseMessage* responsemessage) { clear_data(); if (responsemessage) { set_has_responsemessage(); data_.responsemessage_ = responsemessage; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.GetResponse.responseMessage) } inline ::tunnelbroker::GetResponseMessage* GetResponse::_internal_mutable_responsemessage() { if (!_internal_has_responsemessage()) { clear_data(); set_has_responsemessage(); data_.responsemessage_ = CreateMaybeMessage< ::tunnelbroker::GetResponseMessage >(GetArena()); } return data_.responsemessage_; } inline ::tunnelbroker::GetResponseMessage* GetResponse::mutable_responsemessage() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.responseMessage) return _internal_mutable_responsemessage(); } // .google.protobuf.Empty ping = 2; inline bool GetResponse::_internal_has_ping() const { return data_case() == kPing; } inline bool GetResponse::has_ping() const { return _internal_has_ping(); } inline void GetResponse::set_has_ping() { _oneof_case_[0] = kPing; } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::release_ping() { // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.ping) if (_internal_has_ping()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.ping_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.ping_ = nullptr; return temp; } else { return nullptr; } } inline const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::_internal_ping() const { return _internal_has_ping() ? *data_.ping_ : reinterpret_cast< PROTOBUF_NAMESPACE_ID::Empty&>(PROTOBUF_NAMESPACE_ID::_Empty_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::ping() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.ping) return _internal_ping(); } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::unsafe_arena_release_ping() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.GetResponse.ping) if (_internal_has_ping()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.ping_; data_.ping_ = nullptr; return temp; } else { return nullptr; } } inline void GetResponse::unsafe_arena_set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping) { clear_data(); if (ping) { set_has_ping(); data_.ping_ = ping; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.GetResponse.ping) } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::_internal_mutable_ping() { if (!_internal_has_ping()) { clear_data(); set_has_ping(); data_.ping_ = CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::Empty >(GetArena()); } return data_.ping_; } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::mutable_ping() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.ping) return _internal_mutable_ping(); } // .google.protobuf.Empty newNotifyTokenRequired = 3; inline bool GetResponse::_internal_has_newnotifytokenrequired() const { return data_case() == kNewNotifyTokenRequired; } inline bool GetResponse::has_newnotifytokenrequired() const { return _internal_has_newnotifytokenrequired(); } inline void GetResponse::set_has_newnotifytokenrequired() { _oneof_case_[0] = kNewNotifyTokenRequired; } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::release_newnotifytokenrequired() { // @@protoc_insertion_point(field_release:tunnelbroker.GetResponse.newNotifyTokenRequired) if (_internal_has_newnotifytokenrequired()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.newnotifytokenrequired_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.newnotifytokenrequired_ = nullptr; return temp; } else { return nullptr; } } inline const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::_internal_newnotifytokenrequired() const { return _internal_has_newnotifytokenrequired() ? *data_.newnotifytokenrequired_ : reinterpret_cast< PROTOBUF_NAMESPACE_ID::Empty&>(PROTOBUF_NAMESPACE_ID::_Empty_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Empty& GetResponse::newnotifytokenrequired() const { // @@protoc_insertion_point(field_get:tunnelbroker.GetResponse.newNotifyTokenRequired) return _internal_newnotifytokenrequired(); } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::unsafe_arena_release_newnotifytokenrequired() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.GetResponse.newNotifyTokenRequired) if (_internal_has_newnotifytokenrequired()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.newnotifytokenrequired_; data_.newnotifytokenrequired_ = nullptr; return temp; } else { return nullptr; } } inline void GetResponse::unsafe_arena_set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired) { clear_data(); if (newnotifytokenrequired) { set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = newnotifytokenrequired; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.GetResponse.newNotifyTokenRequired) } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::_internal_mutable_newnotifytokenrequired() { if (!_internal_has_newnotifytokenrequired()) { clear_data(); set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::Empty >(GetArena()); } return data_.newnotifytokenrequired_; } inline PROTOBUF_NAMESPACE_ID::Empty* GetResponse::mutable_newnotifytokenrequired() { // @@protoc_insertion_point(field_mutable:tunnelbroker.GetResponse.newNotifyTokenRequired) return _internal_mutable_newnotifytokenrequired(); } inline bool GetResponse::has_data() const { return data_case() != DATA_NOT_SET; } inline void GetResponse::clear_has_data() { _oneof_case_[0] = DATA_NOT_SET; } inline GetResponse::DataCase GetResponse::data_case() const { return GetResponse::DataCase(_oneof_case_[0]); } // ------------------------------------------------------------------- // ProcessedMessages // repeated string messageID = 1; inline int ProcessedMessages::_internal_messageid_size() const { return messageid_.size(); } inline int ProcessedMessages::messageid_size() const { return _internal_messageid_size(); } inline void ProcessedMessages::clear_messageid() { messageid_.Clear(); } inline std::string* ProcessedMessages::add_messageid() { // @@protoc_insertion_point(field_add_mutable:tunnelbroker.ProcessedMessages.messageID) return _internal_add_messageid(); } inline const std::string& ProcessedMessages::_internal_messageid(int index) const { return messageid_.Get(index); } inline const std::string& ProcessedMessages::messageid(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.ProcessedMessages.messageID) return _internal_messageid(index); } inline std::string* ProcessedMessages::mutable_messageid(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.ProcessedMessages.messageID) return messageid_.Mutable(index); } inline void ProcessedMessages::set_messageid(int index, const std::string& value) { // @@protoc_insertion_point(field_set:tunnelbroker.ProcessedMessages.messageID) messageid_.Mutable(index)->assign(value); } inline void ProcessedMessages::set_messageid(int index, std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.ProcessedMessages.messageID) messageid_.Mutable(index)->assign(std::move(value)); } inline void ProcessedMessages::set_messageid(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); messageid_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:tunnelbroker.ProcessedMessages.messageID) } inline void ProcessedMessages::set_messageid(int index, const char* value, size_t size) { messageid_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.ProcessedMessages.messageID) } inline std::string* ProcessedMessages::_internal_add_messageid() { return messageid_.Add(); } inline void ProcessedMessages::add_messageid(const std::string& value) { messageid_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.ProcessedMessages.messageID) } inline void ProcessedMessages::add_messageid(std::string&& value) { messageid_.Add(std::move(value)); // @@protoc_insertion_point(field_add:tunnelbroker.ProcessedMessages.messageID) } inline void ProcessedMessages::add_messageid(const char* value) { GOOGLE_DCHECK(value != nullptr); messageid_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:tunnelbroker.ProcessedMessages.messageID) } inline void ProcessedMessages::add_messageid(const char* value, size_t size) { messageid_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:tunnelbroker.ProcessedMessages.messageID) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& ProcessedMessages::messageid() const { // @@protoc_insertion_point(field_list:tunnelbroker.ProcessedMessages.messageID) return messageid_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* ProcessedMessages::mutable_messageid() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.ProcessedMessages.messageID) return &messageid_; } // ------------------------------------------------------------------- // MessageToTunnelbrokerStruct // string messageID = 1; inline void MessageToTunnelbrokerStruct::clear_messageid() { messageid_.ClearToEmpty(); } inline const std::string& MessageToTunnelbrokerStruct::messageid() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.messageID) return _internal_messageid(); } inline void MessageToTunnelbrokerStruct::set_messageid(const std::string& value) { _internal_set_messageid(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.messageID) } inline std::string* MessageToTunnelbrokerStruct::mutable_messageid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.messageID) return _internal_mutable_messageid(); } inline const std::string& MessageToTunnelbrokerStruct::_internal_messageid() const { return messageid_.Get(); } inline void MessageToTunnelbrokerStruct::_internal_set_messageid(const std::string& value) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToTunnelbrokerStruct::set_messageid(std::string&& value) { messageid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.messageID) } inline void MessageToTunnelbrokerStruct::set_messageid(const char* value) { GOOGLE_DCHECK(value != nullptr); messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.messageID) } inline void MessageToTunnelbrokerStruct::set_messageid(const char* value, size_t size) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.messageID) } inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_messageid() { return messageid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToTunnelbrokerStruct::release_messageid() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.messageID) return messageid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToTunnelbrokerStruct::set_allocated_messageid(std::string* messageid) { if (messageid != nullptr) { } else { } messageid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), messageid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.messageID) } // string toDeviceID = 2; inline void MessageToTunnelbrokerStruct::clear_todeviceid() { todeviceid_.ClearToEmpty(); } inline const std::string& MessageToTunnelbrokerStruct::todeviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return _internal_todeviceid(); } inline void MessageToTunnelbrokerStruct::set_todeviceid(const std::string& value) { _internal_set_todeviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } inline std::string* MessageToTunnelbrokerStruct::mutable_todeviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return _internal_mutable_todeviceid(); } inline const std::string& MessageToTunnelbrokerStruct::_internal_todeviceid() const { return todeviceid_.Get(); } inline void MessageToTunnelbrokerStruct::_internal_set_todeviceid(const std::string& value) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToTunnelbrokerStruct::set_todeviceid(std::string&& value) { todeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } inline void MessageToTunnelbrokerStruct::set_todeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } inline void MessageToTunnelbrokerStruct::set_todeviceid(const char* value, size_t size) { todeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_todeviceid() { return todeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToTunnelbrokerStruct::release_todeviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) return todeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToTunnelbrokerStruct::set_allocated_todeviceid(std::string* todeviceid) { if (todeviceid != nullptr) { } else { } todeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), todeviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.toDeviceID) } // string payload = 3; inline void MessageToTunnelbrokerStruct::clear_payload() { payload_.ClearToEmpty(); } inline const std::string& MessageToTunnelbrokerStruct::payload() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.payload) return _internal_payload(); } inline void MessageToTunnelbrokerStruct::set_payload(const std::string& value) { _internal_set_payload(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.payload) } inline std::string* MessageToTunnelbrokerStruct::mutable_payload() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.payload) return _internal_mutable_payload(); } inline const std::string& MessageToTunnelbrokerStruct::_internal_payload() const { return payload_.Get(); } inline void MessageToTunnelbrokerStruct::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToTunnelbrokerStruct::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbrokerStruct.payload) } inline void MessageToTunnelbrokerStruct::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.payload) } inline void MessageToTunnelbrokerStruct::set_payload(const char* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.payload) } inline std::string* MessageToTunnelbrokerStruct::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToTunnelbrokerStruct::release_payload() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbrokerStruct.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToTunnelbrokerStruct::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbrokerStruct.payload) } // repeated string blobHashes = 4; inline int MessageToTunnelbrokerStruct::_internal_blobhashes_size() const { return blobhashes_.size(); } inline int MessageToTunnelbrokerStruct::blobhashes_size() const { return _internal_blobhashes_size(); } inline void MessageToTunnelbrokerStruct::clear_blobhashes() { blobhashes_.Clear(); } inline std::string* MessageToTunnelbrokerStruct::add_blobhashes() { // @@protoc_insertion_point(field_add_mutable:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return _internal_add_blobhashes(); } inline const std::string& MessageToTunnelbrokerStruct::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } inline const std::string& MessageToTunnelbrokerStruct::blobhashes(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return _internal_blobhashes(index); } inline std::string* MessageToTunnelbrokerStruct::mutable_blobhashes(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return blobhashes_.Mutable(index); } inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const std::string& value) { // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) blobhashes_.Mutable(index)->assign(value); } inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline void MessageToTunnelbrokerStruct::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline std::string* MessageToTunnelbrokerStruct::_internal_add_blobhashes() { return blobhashes_.Add(); } inline void MessageToTunnelbrokerStruct::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline void MessageToTunnelbrokerStruct::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); // @@protoc_insertion_point(field_add:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline void MessageToTunnelbrokerStruct::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline void MessageToTunnelbrokerStruct::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& MessageToTunnelbrokerStruct::blobhashes() const { // @@protoc_insertion_point(field_list:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* MessageToTunnelbrokerStruct::mutable_blobhashes() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessageToTunnelbrokerStruct.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- // MessagesToSend // repeated .tunnelbroker.MessageToTunnelbrokerStruct messages = 1; inline int MessagesToSend::_internal_messages_size() const { return messages_.size(); } inline int MessagesToSend::messages_size() const { return _internal_messages_size(); } inline void MessagesToSend::clear_messages() { messages_.Clear(); } inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::mutable_messages(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessagesToSend.messages) return messages_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >* MessagesToSend::mutable_messages() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessagesToSend.messages) return &messages_; } inline const ::tunnelbroker::MessageToTunnelbrokerStruct& MessagesToSend::_internal_messages(int index) const { return messages_.Get(index); } inline const ::tunnelbroker::MessageToTunnelbrokerStruct& MessagesToSend::messages(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.MessagesToSend.messages) return _internal_messages(index); } inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::_internal_add_messages() { return messages_.Add(); } inline ::tunnelbroker::MessageToTunnelbrokerStruct* MessagesToSend::add_messages() { // @@protoc_insertion_point(field_add:tunnelbroker.MessagesToSend.messages) return _internal_add_messages(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToTunnelbrokerStruct >& MessagesToSend::messages() const { // @@protoc_insertion_point(field_list:tunnelbroker.MessagesToSend.messages) return messages_; } // ------------------------------------------------------------------- // MessageToTunnelbroker -// string sessionID = 1; -inline void MessageToTunnelbroker::clear_sessionid() { - sessionid_.ClearToEmpty(); -} -inline const std::string& MessageToTunnelbroker::sessionid() const { - // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.sessionID) - return _internal_sessionid(); -} -inline void MessageToTunnelbroker::set_sessionid(const std::string& value) { - _internal_set_sessionid(value); - // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbroker.sessionID) -} -inline std::string* MessageToTunnelbroker::mutable_sessionid() { - // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.sessionID) - return _internal_mutable_sessionid(); -} -inline const std::string& MessageToTunnelbroker::_internal_sessionid() const { - return sessionid_.Get(); -} -inline void MessageToTunnelbroker::_internal_set_sessionid(const std::string& value) { - - sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline void MessageToTunnelbroker::set_sessionid(std::string&& value) { - - sessionid_.Set( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); - // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbroker.sessionID) -} -inline void MessageToTunnelbroker::set_sessionid(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); - // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbroker.sessionID) -} -inline void MessageToTunnelbroker::set_sessionid(const char* value, - size_t size) { - - sessionid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( - reinterpret_cast(value), size), GetArena()); - // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbroker.sessionID) -} -inline std::string* MessageToTunnelbroker::_internal_mutable_sessionid() { - - return sessionid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* MessageToTunnelbroker::release_sessionid() { - // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.sessionID) - return sessionid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void MessageToTunnelbroker::set_allocated_sessionid(std::string* sessionid) { - if (sessionid != nullptr) { - - } else { - - } - sessionid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sessionid, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.sessionID) -} - -// .tunnelbroker.MessagesToSend messagesToSend = 2; +// .tunnelbroker.MessagesToSend messagesToSend = 1; inline bool MessageToTunnelbroker::_internal_has_messagestosend() const { return data_case() == kMessagesToSend; } inline bool MessageToTunnelbroker::has_messagestosend() const { return _internal_has_messagestosend(); } inline void MessageToTunnelbroker::set_has_messagestosend() { _oneof_case_[0] = kMessagesToSend; } inline void MessageToTunnelbroker::clear_messagestosend() { if (_internal_has_messagestosend()) { if (GetArena() == nullptr) { delete data_.messagestosend_; } clear_has_data(); } } inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::release_messagestosend() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.messagesToSend) if (_internal_has_messagestosend()) { clear_has_data(); ::tunnelbroker::MessagesToSend* temp = data_.messagestosend_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.messagestosend_ = nullptr; return temp; } else { return nullptr; } } inline const ::tunnelbroker::MessagesToSend& MessageToTunnelbroker::_internal_messagestosend() const { return _internal_has_messagestosend() ? *data_.messagestosend_ : reinterpret_cast< ::tunnelbroker::MessagesToSend&>(::tunnelbroker::_MessagesToSend_default_instance_); } inline const ::tunnelbroker::MessagesToSend& MessageToTunnelbroker::messagestosend() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.messagesToSend) return _internal_messagestosend(); } inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::unsafe_arena_release_messagestosend() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToTunnelbroker.messagesToSend) if (_internal_has_messagestosend()) { clear_has_data(); ::tunnelbroker::MessagesToSend* temp = data_.messagestosend_; data_.messagestosend_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToTunnelbroker::unsafe_arena_set_allocated_messagestosend(::tunnelbroker::MessagesToSend* messagestosend) { clear_data(); if (messagestosend) { set_has_messagestosend(); data_.messagestosend_ = messagestosend; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToTunnelbroker.messagesToSend) } inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::_internal_mutable_messagestosend() { if (!_internal_has_messagestosend()) { clear_data(); set_has_messagestosend(); data_.messagestosend_ = CreateMaybeMessage< ::tunnelbroker::MessagesToSend >(GetArena()); } return data_.messagestosend_; } inline ::tunnelbroker::MessagesToSend* MessageToTunnelbroker::mutable_messagestosend() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.messagesToSend) return _internal_mutable_messagestosend(); } -// .tunnelbroker.ProcessedMessages processedMessages = 3; +// .tunnelbroker.ProcessedMessages processedMessages = 2; inline bool MessageToTunnelbroker::_internal_has_processedmessages() const { return data_case() == kProcessedMessages; } inline bool MessageToTunnelbroker::has_processedmessages() const { return _internal_has_processedmessages(); } inline void MessageToTunnelbroker::set_has_processedmessages() { _oneof_case_[0] = kProcessedMessages; } inline void MessageToTunnelbroker::clear_processedmessages() { if (_internal_has_processedmessages()) { if (GetArena() == nullptr) { delete data_.processedmessages_; } clear_has_data(); } } inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::release_processedmessages() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.processedMessages) if (_internal_has_processedmessages()) { clear_has_data(); ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.processedmessages_ = nullptr; return temp; } else { return nullptr; } } inline const ::tunnelbroker::ProcessedMessages& MessageToTunnelbroker::_internal_processedmessages() const { return _internal_has_processedmessages() ? *data_.processedmessages_ : reinterpret_cast< ::tunnelbroker::ProcessedMessages&>(::tunnelbroker::_ProcessedMessages_default_instance_); } inline const ::tunnelbroker::ProcessedMessages& MessageToTunnelbroker::processedmessages() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.processedMessages) return _internal_processedmessages(); } inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::unsafe_arena_release_processedmessages() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToTunnelbroker.processedMessages) if (_internal_has_processedmessages()) { clear_has_data(); ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; data_.processedmessages_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToTunnelbroker::unsafe_arena_set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { clear_data(); if (processedmessages) { set_has_processedmessages(); data_.processedmessages_ = processedmessages; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToTunnelbroker.processedMessages) } inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::_internal_mutable_processedmessages() { if (!_internal_has_processedmessages()) { clear_data(); set_has_processedmessages(); data_.processedmessages_ = CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(GetArena()); } return data_.processedmessages_; } inline ::tunnelbroker::ProcessedMessages* MessageToTunnelbroker::mutable_processedmessages() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.processedMessages) return _internal_mutable_processedmessages(); } -// string newNotifyToken = 4; +// string newNotifyToken = 3; inline bool MessageToTunnelbroker::_internal_has_newnotifytoken() const { return data_case() == kNewNotifyToken; } inline bool MessageToTunnelbroker::has_newnotifytoken() const { return _internal_has_newnotifytoken(); } inline void MessageToTunnelbroker::set_has_newnotifytoken() { _oneof_case_[0] = kNewNotifyToken; } inline void MessageToTunnelbroker::clear_newnotifytoken() { if (_internal_has_newnotifytoken()) { data_.newnotifytoken_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); clear_has_data(); } } inline const std::string& MessageToTunnelbroker::newnotifytoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToTunnelbroker.newNotifyToken) return _internal_newnotifytoken(); } inline void MessageToTunnelbroker::set_newnotifytoken(const std::string& value) { _internal_set_newnotifytoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbroker.newNotifyToken) } inline std::string* MessageToTunnelbroker::mutable_newnotifytoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToTunnelbroker.newNotifyToken) return _internal_mutable_newnotifytoken(); } inline const std::string& MessageToTunnelbroker::_internal_newnotifytoken() const { if (_internal_has_newnotifytoken()) { return data_.newnotifytoken_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } inline void MessageToTunnelbroker::_internal_set_newnotifytoken(const std::string& value) { if (!_internal_has_newnotifytoken()) { clear_data(); set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } data_.newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToTunnelbroker::set_newnotifytoken(std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.MessageToTunnelbroker.newNotifyToken) if (!_internal_has_newnotifytoken()) { clear_data(); set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } data_.newnotifytoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToTunnelbroker.newNotifyToken) } inline void MessageToTunnelbroker::set_newnotifytoken(const char* value) { GOOGLE_DCHECK(value != nullptr); if (!_internal_has_newnotifytoken()) { clear_data(); set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } data_.newnotifytoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToTunnelbroker.newNotifyToken) } inline void MessageToTunnelbroker::set_newnotifytoken(const char* value, size_t size) { if (!_internal_has_newnotifytoken()) { clear_data(); set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } data_.newnotifytoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToTunnelbroker.newNotifyToken) } inline std::string* MessageToTunnelbroker::_internal_mutable_newnotifytoken() { if (!_internal_has_newnotifytoken()) { clear_data(); set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return data_.newnotifytoken_.Mutable( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToTunnelbroker::release_newnotifytoken() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToTunnelbroker.newNotifyToken) if (_internal_has_newnotifytoken()) { clear_has_data(); return data_.newnotifytoken_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } inline void MessageToTunnelbroker::set_allocated_newnotifytoken(std::string* newnotifytoken) { if (has_data()) { clear_data(); } if (newnotifytoken != nullptr) { set_has_newnotifytoken(); data_.newnotifytoken_.UnsafeSetDefault(newnotifytoken); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { arena->Own(newnotifytoken); } } // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToTunnelbroker.newNotifyToken) } inline bool MessageToTunnelbroker::has_data() const { return data_case() != DATA_NOT_SET; } inline void MessageToTunnelbroker::clear_has_data() { _oneof_case_[0] = DATA_NOT_SET; } inline MessageToTunnelbroker::DataCase MessageToTunnelbroker::data_case() const { return MessageToTunnelbroker::DataCase(_oneof_case_[0]); } // ------------------------------------------------------------------- // MessageToClientStruct // string messageID = 1; inline void MessageToClientStruct::clear_messageid() { messageid_.ClearToEmpty(); } inline const std::string& MessageToClientStruct::messageid() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.messageID) return _internal_messageid(); } inline void MessageToClientStruct::set_messageid(const std::string& value) { _internal_set_messageid(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.messageID) } inline std::string* MessageToClientStruct::mutable_messageid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.messageID) return _internal_mutable_messageid(); } inline const std::string& MessageToClientStruct::_internal_messageid() const { return messageid_.Get(); } inline void MessageToClientStruct::_internal_set_messageid(const std::string& value) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToClientStruct::set_messageid(std::string&& value) { messageid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.messageID) } inline void MessageToClientStruct::set_messageid(const char* value) { GOOGLE_DCHECK(value != nullptr); messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.messageID) } inline void MessageToClientStruct::set_messageid(const char* value, size_t size) { messageid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.messageID) } inline std::string* MessageToClientStruct::_internal_mutable_messageid() { return messageid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToClientStruct::release_messageid() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.messageID) return messageid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToClientStruct::set_allocated_messageid(std::string* messageid) { if (messageid != nullptr) { } else { } messageid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), messageid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.messageID) } // string fromDeviceID = 2; inline void MessageToClientStruct::clear_fromdeviceid() { fromdeviceid_.ClearToEmpty(); } inline const std::string& MessageToClientStruct::fromdeviceid() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.fromDeviceID) return _internal_fromdeviceid(); } inline void MessageToClientStruct::set_fromdeviceid(const std::string& value) { _internal_set_fromdeviceid(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.fromDeviceID) } inline std::string* MessageToClientStruct::mutable_fromdeviceid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.fromDeviceID) return _internal_mutable_fromdeviceid(); } inline const std::string& MessageToClientStruct::_internal_fromdeviceid() const { return fromdeviceid_.Get(); } inline void MessageToClientStruct::_internal_set_fromdeviceid(const std::string& value) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToClientStruct::set_fromdeviceid(std::string&& value) { fromdeviceid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.fromDeviceID) } inline void MessageToClientStruct::set_fromdeviceid(const char* value) { GOOGLE_DCHECK(value != nullptr); fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.fromDeviceID) } inline void MessageToClientStruct::set_fromdeviceid(const char* value, size_t size) { fromdeviceid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.fromDeviceID) } inline std::string* MessageToClientStruct::_internal_mutable_fromdeviceid() { return fromdeviceid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToClientStruct::release_fromdeviceid() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.fromDeviceID) return fromdeviceid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToClientStruct::set_allocated_fromdeviceid(std::string* fromdeviceid) { if (fromdeviceid != nullptr) { } else { } fromdeviceid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fromdeviceid, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.fromDeviceID) } // string payload = 3; inline void MessageToClientStruct::clear_payload() { payload_.ClearToEmpty(); } inline const std::string& MessageToClientStruct::payload() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.payload) return _internal_payload(); } inline void MessageToClientStruct::set_payload(const std::string& value) { _internal_set_payload(value); // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.payload) } inline std::string* MessageToClientStruct::mutable_payload() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.payload) return _internal_mutable_payload(); } inline const std::string& MessageToClientStruct::_internal_payload() const { return payload_.Get(); } inline void MessageToClientStruct::_internal_set_payload(const std::string& value) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void MessageToClientStruct::set_payload(std::string&& value) { payload_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.MessageToClientStruct.payload) } inline void MessageToClientStruct::set_payload(const char* value) { GOOGLE_DCHECK(value != nullptr); payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.payload) } inline void MessageToClientStruct::set_payload(const char* value, size_t size) { payload_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.payload) } inline std::string* MessageToClientStruct::_internal_mutable_payload() { return payload_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* MessageToClientStruct::release_payload() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClientStruct.payload) return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void MessageToClientStruct::set_allocated_payload(std::string* payload) { if (payload != nullptr) { } else { } payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.MessageToClientStruct.payload) } // repeated string blobHashes = 4; inline int MessageToClientStruct::_internal_blobhashes_size() const { return blobhashes_.size(); } inline int MessageToClientStruct::blobhashes_size() const { return _internal_blobhashes_size(); } inline void MessageToClientStruct::clear_blobhashes() { blobhashes_.Clear(); } inline std::string* MessageToClientStruct::add_blobhashes() { // @@protoc_insertion_point(field_add_mutable:tunnelbroker.MessageToClientStruct.blobHashes) return _internal_add_blobhashes(); } inline const std::string& MessageToClientStruct::_internal_blobhashes(int index) const { return blobhashes_.Get(index); } inline const std::string& MessageToClientStruct::blobhashes(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClientStruct.blobHashes) return _internal_blobhashes(index); } inline std::string* MessageToClientStruct::mutable_blobhashes(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClientStruct.blobHashes) return blobhashes_.Mutable(index); } inline void MessageToClientStruct::set_blobhashes(int index, const std::string& value) { // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.blobHashes) blobhashes_.Mutable(index)->assign(value); } inline void MessageToClientStruct::set_blobhashes(int index, std::string&& value) { // @@protoc_insertion_point(field_set:tunnelbroker.MessageToClientStruct.blobHashes) blobhashes_.Mutable(index)->assign(std::move(value)); } inline void MessageToClientStruct::set_blobhashes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:tunnelbroker.MessageToClientStruct.blobHashes) } inline void MessageToClientStruct::set_blobhashes(int index, const char* value, size_t size) { blobhashes_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.MessageToClientStruct.blobHashes) } inline std::string* MessageToClientStruct::_internal_add_blobhashes() { return blobhashes_.Add(); } inline void MessageToClientStruct::add_blobhashes(const std::string& value) { blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add:tunnelbroker.MessageToClientStruct.blobHashes) } inline void MessageToClientStruct::add_blobhashes(std::string&& value) { blobhashes_.Add(std::move(value)); // @@protoc_insertion_point(field_add:tunnelbroker.MessageToClientStruct.blobHashes) } inline void MessageToClientStruct::add_blobhashes(const char* value) { GOOGLE_DCHECK(value != nullptr); blobhashes_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:tunnelbroker.MessageToClientStruct.blobHashes) } inline void MessageToClientStruct::add_blobhashes(const char* value, size_t size) { blobhashes_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:tunnelbroker.MessageToClientStruct.blobHashes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& MessageToClientStruct::blobhashes() const { // @@protoc_insertion_point(field_list:tunnelbroker.MessageToClientStruct.blobHashes) return blobhashes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* MessageToClientStruct::mutable_blobhashes() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessageToClientStruct.blobHashes) return &blobhashes_; } // ------------------------------------------------------------------- // MessagesToDeliver // repeated .tunnelbroker.MessageToClientStruct messages = 1; inline int MessagesToDeliver::_internal_messages_size() const { return messages_.size(); } inline int MessagesToDeliver::messages_size() const { return _internal_messages_size(); } inline void MessagesToDeliver::clear_messages() { messages_.Clear(); } inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::mutable_messages(int index) { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessagesToDeliver.messages) return messages_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >* MessagesToDeliver::mutable_messages() { // @@protoc_insertion_point(field_mutable_list:tunnelbroker.MessagesToDeliver.messages) return &messages_; } inline const ::tunnelbroker::MessageToClientStruct& MessagesToDeliver::_internal_messages(int index) const { return messages_.Get(index); } inline const ::tunnelbroker::MessageToClientStruct& MessagesToDeliver::messages(int index) const { // @@protoc_insertion_point(field_get:tunnelbroker.MessagesToDeliver.messages) return _internal_messages(index); } inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::_internal_add_messages() { return messages_.Add(); } inline ::tunnelbroker::MessageToClientStruct* MessagesToDeliver::add_messages() { // @@protoc_insertion_point(field_add:tunnelbroker.MessagesToDeliver.messages) return _internal_add_messages(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tunnelbroker::MessageToClientStruct >& MessagesToDeliver::messages() const { // @@protoc_insertion_point(field_list:tunnelbroker.MessagesToDeliver.messages) return messages_; } // ------------------------------------------------------------------- // MessageToClient // .tunnelbroker.MessagesToDeliver messagesToDeliver = 1; inline bool MessageToClient::_internal_has_messagestodeliver() const { return data_case() == kMessagesToDeliver; } inline bool MessageToClient::has_messagestodeliver() const { return _internal_has_messagestodeliver(); } inline void MessageToClient::set_has_messagestodeliver() { _oneof_case_[0] = kMessagesToDeliver; } inline void MessageToClient::clear_messagestodeliver() { if (_internal_has_messagestodeliver()) { if (GetArena() == nullptr) { delete data_.messagestodeliver_; } clear_has_data(); } } inline ::tunnelbroker::MessagesToDeliver* MessageToClient::release_messagestodeliver() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.messagesToDeliver) if (_internal_has_messagestodeliver()) { clear_has_data(); ::tunnelbroker::MessagesToDeliver* temp = data_.messagestodeliver_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.messagestodeliver_ = nullptr; return temp; } else { return nullptr; } } inline const ::tunnelbroker::MessagesToDeliver& MessageToClient::_internal_messagestodeliver() const { return _internal_has_messagestodeliver() ? *data_.messagestodeliver_ : reinterpret_cast< ::tunnelbroker::MessagesToDeliver&>(::tunnelbroker::_MessagesToDeliver_default_instance_); } inline const ::tunnelbroker::MessagesToDeliver& MessageToClient::messagestodeliver() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.messagesToDeliver) return _internal_messagestodeliver(); } inline ::tunnelbroker::MessagesToDeliver* MessageToClient::unsafe_arena_release_messagestodeliver() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.messagesToDeliver) if (_internal_has_messagestodeliver()) { clear_has_data(); ::tunnelbroker::MessagesToDeliver* temp = data_.messagestodeliver_; data_.messagestodeliver_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToClient::unsafe_arena_set_allocated_messagestodeliver(::tunnelbroker::MessagesToDeliver* messagestodeliver) { clear_data(); if (messagestodeliver) { set_has_messagestodeliver(); data_.messagestodeliver_ = messagestodeliver; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.messagesToDeliver) } inline ::tunnelbroker::MessagesToDeliver* MessageToClient::_internal_mutable_messagestodeliver() { if (!_internal_has_messagestodeliver()) { clear_data(); set_has_messagestodeliver(); data_.messagestodeliver_ = CreateMaybeMessage< ::tunnelbroker::MessagesToDeliver >(GetArena()); } return data_.messagestodeliver_; } inline ::tunnelbroker::MessagesToDeliver* MessageToClient::mutable_messagestodeliver() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.messagesToDeliver) return _internal_mutable_messagestodeliver(); } // .tunnelbroker.ProcessedMessages processedMessages = 2; inline bool MessageToClient::_internal_has_processedmessages() const { return data_case() == kProcessedMessages; } inline bool MessageToClient::has_processedmessages() const { return _internal_has_processedmessages(); } inline void MessageToClient::set_has_processedmessages() { _oneof_case_[0] = kProcessedMessages; } inline void MessageToClient::clear_processedmessages() { if (_internal_has_processedmessages()) { if (GetArena() == nullptr) { delete data_.processedmessages_; } clear_has_data(); } } inline ::tunnelbroker::ProcessedMessages* MessageToClient::release_processedmessages() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.processedMessages) if (_internal_has_processedmessages()) { clear_has_data(); ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.processedmessages_ = nullptr; return temp; } else { return nullptr; } } inline const ::tunnelbroker::ProcessedMessages& MessageToClient::_internal_processedmessages() const { return _internal_has_processedmessages() ? *data_.processedmessages_ : reinterpret_cast< ::tunnelbroker::ProcessedMessages&>(::tunnelbroker::_ProcessedMessages_default_instance_); } inline const ::tunnelbroker::ProcessedMessages& MessageToClient::processedmessages() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.processedMessages) return _internal_processedmessages(); } inline ::tunnelbroker::ProcessedMessages* MessageToClient::unsafe_arena_release_processedmessages() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.processedMessages) if (_internal_has_processedmessages()) { clear_has_data(); ::tunnelbroker::ProcessedMessages* temp = data_.processedmessages_; data_.processedmessages_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToClient::unsafe_arena_set_allocated_processedmessages(::tunnelbroker::ProcessedMessages* processedmessages) { clear_data(); if (processedmessages) { set_has_processedmessages(); data_.processedmessages_ = processedmessages; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.processedMessages) } inline ::tunnelbroker::ProcessedMessages* MessageToClient::_internal_mutable_processedmessages() { if (!_internal_has_processedmessages()) { clear_data(); set_has_processedmessages(); data_.processedmessages_ = CreateMaybeMessage< ::tunnelbroker::ProcessedMessages >(GetArena()); } return data_.processedmessages_; } inline ::tunnelbroker::ProcessedMessages* MessageToClient::mutable_processedmessages() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.processedMessages) return _internal_mutable_processedmessages(); } // .google.protobuf.Empty newNotifyTokenRequired = 3; inline bool MessageToClient::_internal_has_newnotifytokenrequired() const { return data_case() == kNewNotifyTokenRequired; } inline bool MessageToClient::has_newnotifytokenrequired() const { return _internal_has_newnotifytokenrequired(); } inline void MessageToClient::set_has_newnotifytokenrequired() { _oneof_case_[0] = kNewNotifyTokenRequired; } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::release_newnotifytokenrequired() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.newNotifyTokenRequired) if (_internal_has_newnotifytokenrequired()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.newnotifytokenrequired_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.newnotifytokenrequired_ = nullptr; return temp; } else { return nullptr; } } inline const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::_internal_newnotifytokenrequired() const { return _internal_has_newnotifytokenrequired() ? *data_.newnotifytokenrequired_ : reinterpret_cast< PROTOBUF_NAMESPACE_ID::Empty&>(PROTOBUF_NAMESPACE_ID::_Empty_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::newnotifytokenrequired() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.newNotifyTokenRequired) return _internal_newnotifytokenrequired(); } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::unsafe_arena_release_newnotifytokenrequired() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.newNotifyTokenRequired) if (_internal_has_newnotifytokenrequired()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.newnotifytokenrequired_; data_.newnotifytokenrequired_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToClient::unsafe_arena_set_allocated_newnotifytokenrequired(PROTOBUF_NAMESPACE_ID::Empty* newnotifytokenrequired) { clear_data(); if (newnotifytokenrequired) { set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = newnotifytokenrequired; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.newNotifyTokenRequired) } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::_internal_mutable_newnotifytokenrequired() { if (!_internal_has_newnotifytokenrequired()) { clear_data(); set_has_newnotifytokenrequired(); data_.newnotifytokenrequired_ = CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::Empty >(GetArena()); } return data_.newnotifytokenrequired_; } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::mutable_newnotifytokenrequired() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.newNotifyTokenRequired) return _internal_mutable_newnotifytokenrequired(); } // .google.protobuf.Empty ping = 4; inline bool MessageToClient::_internal_has_ping() const { return data_case() == kPing; } inline bool MessageToClient::has_ping() const { return _internal_has_ping(); } inline void MessageToClient::set_has_ping() { _oneof_case_[0] = kPing; } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::release_ping() { // @@protoc_insertion_point(field_release:tunnelbroker.MessageToClient.ping) if (_internal_has_ping()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.ping_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } data_.ping_ = nullptr; return temp; } else { return nullptr; } } inline const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::_internal_ping() const { return _internal_has_ping() ? *data_.ping_ : reinterpret_cast< PROTOBUF_NAMESPACE_ID::Empty&>(PROTOBUF_NAMESPACE_ID::_Empty_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Empty& MessageToClient::ping() const { // @@protoc_insertion_point(field_get:tunnelbroker.MessageToClient.ping) return _internal_ping(); } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::unsafe_arena_release_ping() { // @@protoc_insertion_point(field_unsafe_arena_release:tunnelbroker.MessageToClient.ping) if (_internal_has_ping()) { clear_has_data(); PROTOBUF_NAMESPACE_ID::Empty* temp = data_.ping_; data_.ping_ = nullptr; return temp; } else { return nullptr; } } inline void MessageToClient::unsafe_arena_set_allocated_ping(PROTOBUF_NAMESPACE_ID::Empty* ping) { clear_data(); if (ping) { set_has_ping(); data_.ping_ = ping; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tunnelbroker.MessageToClient.ping) } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::_internal_mutable_ping() { if (!_internal_has_ping()) { clear_data(); set_has_ping(); data_.ping_ = CreateMaybeMessage< PROTOBUF_NAMESPACE_ID::Empty >(GetArena()); } return data_.ping_; } inline PROTOBUF_NAMESPACE_ID::Empty* MessageToClient::mutable_ping() { // @@protoc_insertion_point(field_mutable:tunnelbroker.MessageToClient.ping) return _internal_mutable_ping(); } inline bool MessageToClient::has_data() const { return data_case() != DATA_NOT_SET; } inline void MessageToClient::clear_has_data() { _oneof_case_[0] = DATA_NOT_SET; } inline MessageToClient::DataCase MessageToClient::data_case() const { return MessageToClient::DataCase(_oneof_case_[0]); } // ------------------------------------------------------------------- // CheckRequest // string userId = 1; inline void CheckRequest::clear_userid() { userid_.ClearToEmpty(); } inline const std::string& CheckRequest::userid() const { // @@protoc_insertion_point(field_get:tunnelbroker.CheckRequest.userId) return _internal_userid(); } inline void CheckRequest::set_userid(const std::string& value) { _internal_set_userid(value); // @@protoc_insertion_point(field_set:tunnelbroker.CheckRequest.userId) } inline std::string* CheckRequest::mutable_userid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.CheckRequest.userId) return _internal_mutable_userid(); } inline const std::string& CheckRequest::_internal_userid() const { return userid_.Get(); } inline void CheckRequest::_internal_set_userid(const std::string& value) { userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void CheckRequest::set_userid(std::string&& value) { userid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.CheckRequest.userId) } inline void CheckRequest::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:tunnelbroker.CheckRequest.userId) } inline void CheckRequest::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:tunnelbroker.CheckRequest.userId) } inline std::string* CheckRequest::_internal_mutable_userid() { return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* CheckRequest::release_userid() { // @@protoc_insertion_point(field_release:tunnelbroker.CheckRequest.userId) return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void CheckRequest::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:tunnelbroker.CheckRequest.userId) } // string deviceToken = 2; inline void CheckRequest::clear_devicetoken() { devicetoken_.ClearToEmpty(); } inline const std::string& CheckRequest::devicetoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.CheckRequest.deviceToken) return _internal_devicetoken(); } inline void CheckRequest::set_devicetoken(const std::string& value) { _internal_set_devicetoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.CheckRequest.deviceToken) } inline std::string* CheckRequest::mutable_devicetoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.CheckRequest.deviceToken) return _internal_mutable_devicetoken(); } inline const std::string& CheckRequest::_internal_devicetoken() const { return devicetoken_.Get(); } inline void CheckRequest::_internal_set_devicetoken(const std::string& value) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void CheckRequest::set_devicetoken(std::string&& value) { devicetoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.CheckRequest.deviceToken) } inline void CheckRequest::set_devicetoken(const char* value) { GOOGLE_DCHECK(value != nullptr); devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.CheckRequest.deviceToken) } inline void CheckRequest::set_devicetoken(const char* value, size_t size) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.CheckRequest.deviceToken) } inline std::string* CheckRequest::_internal_mutable_devicetoken() { return devicetoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* CheckRequest::release_devicetoken() { // @@protoc_insertion_point(field_release:tunnelbroker.CheckRequest.deviceToken) return devicetoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void CheckRequest::set_allocated_devicetoken(std::string* devicetoken) { if (devicetoken != nullptr) { } else { } devicetoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), devicetoken, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.CheckRequest.deviceToken) } // ------------------------------------------------------------------- // CheckResponse // .tunnelbroker.CheckResponseType checkResponseType = 1; inline void CheckResponse::clear_checkresponsetype() { checkresponsetype_ = 0; } inline ::tunnelbroker::CheckResponseType CheckResponse::_internal_checkresponsetype() const { return static_cast< ::tunnelbroker::CheckResponseType >(checkresponsetype_); } inline ::tunnelbroker::CheckResponseType CheckResponse::checkresponsetype() const { // @@protoc_insertion_point(field_get:tunnelbroker.CheckResponse.checkResponseType) return _internal_checkresponsetype(); } inline void CheckResponse::_internal_set_checkresponsetype(::tunnelbroker::CheckResponseType value) { checkresponsetype_ = value; } inline void CheckResponse::set_checkresponsetype(::tunnelbroker::CheckResponseType value) { _internal_set_checkresponsetype(value); // @@protoc_insertion_point(field_set:tunnelbroker.CheckResponse.checkResponseType) } // ------------------------------------------------------------------- // NewPrimaryRequest // string userId = 1; inline void NewPrimaryRequest::clear_userid() { userid_.ClearToEmpty(); } inline const std::string& NewPrimaryRequest::userid() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewPrimaryRequest.userId) return _internal_userid(); } inline void NewPrimaryRequest::set_userid(const std::string& value) { _internal_set_userid(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewPrimaryRequest.userId) } inline std::string* NewPrimaryRequest::mutable_userid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewPrimaryRequest.userId) return _internal_mutable_userid(); } inline const std::string& NewPrimaryRequest::_internal_userid() const { return userid_.Get(); } inline void NewPrimaryRequest::_internal_set_userid(const std::string& value) { userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewPrimaryRequest::set_userid(std::string&& value) { userid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewPrimaryRequest.userId) } inline void NewPrimaryRequest::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:tunnelbroker.NewPrimaryRequest.userId) } inline void NewPrimaryRequest::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:tunnelbroker.NewPrimaryRequest.userId) } inline std::string* NewPrimaryRequest::_internal_mutable_userid() { return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewPrimaryRequest::release_userid() { // @@protoc_insertion_point(field_release:tunnelbroker.NewPrimaryRequest.userId) return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewPrimaryRequest::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:tunnelbroker.NewPrimaryRequest.userId) } // string deviceToken = 2; inline void NewPrimaryRequest::clear_devicetoken() { devicetoken_.ClearToEmpty(); } inline const std::string& NewPrimaryRequest::devicetoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewPrimaryRequest.deviceToken) return _internal_devicetoken(); } inline void NewPrimaryRequest::set_devicetoken(const std::string& value) { _internal_set_devicetoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewPrimaryRequest.deviceToken) } inline std::string* NewPrimaryRequest::mutable_devicetoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.NewPrimaryRequest.deviceToken) return _internal_mutable_devicetoken(); } inline const std::string& NewPrimaryRequest::_internal_devicetoken() const { return devicetoken_.Get(); } inline void NewPrimaryRequest::_internal_set_devicetoken(const std::string& value) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void NewPrimaryRequest::set_devicetoken(std::string&& value) { devicetoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.NewPrimaryRequest.deviceToken) } inline void NewPrimaryRequest::set_devicetoken(const char* value) { GOOGLE_DCHECK(value != nullptr); devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.NewPrimaryRequest.deviceToken) } inline void NewPrimaryRequest::set_devicetoken(const char* value, size_t size) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.NewPrimaryRequest.deviceToken) } inline std::string* NewPrimaryRequest::_internal_mutable_devicetoken() { return devicetoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* NewPrimaryRequest::release_devicetoken() { // @@protoc_insertion_point(field_release:tunnelbroker.NewPrimaryRequest.deviceToken) return devicetoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void NewPrimaryRequest::set_allocated_devicetoken(std::string* devicetoken) { if (devicetoken != nullptr) { } else { } devicetoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), devicetoken, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.NewPrimaryRequest.deviceToken) } // ------------------------------------------------------------------- // NewPrimaryResponse // bool success = 1; inline void NewPrimaryResponse::clear_success() { success_ = false; } inline bool NewPrimaryResponse::_internal_success() const { return success_; } inline bool NewPrimaryResponse::success() const { // @@protoc_insertion_point(field_get:tunnelbroker.NewPrimaryResponse.success) return _internal_success(); } inline void NewPrimaryResponse::_internal_set_success(bool value) { success_ = value; } inline void NewPrimaryResponse::set_success(bool value) { _internal_set_success(value); // @@protoc_insertion_point(field_set:tunnelbroker.NewPrimaryResponse.success) } // ------------------------------------------------------------------- // PongRequest // string userId = 1; inline void PongRequest::clear_userid() { userid_.ClearToEmpty(); } inline const std::string& PongRequest::userid() const { // @@protoc_insertion_point(field_get:tunnelbroker.PongRequest.userId) return _internal_userid(); } inline void PongRequest::set_userid(const std::string& value) { _internal_set_userid(value); // @@protoc_insertion_point(field_set:tunnelbroker.PongRequest.userId) } inline std::string* PongRequest::mutable_userid() { // @@protoc_insertion_point(field_mutable:tunnelbroker.PongRequest.userId) return _internal_mutable_userid(); } inline const std::string& PongRequest::_internal_userid() const { return userid_.Get(); } inline void PongRequest::_internal_set_userid(const std::string& value) { userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void PongRequest::set_userid(std::string&& value) { userid_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.PongRequest.userId) } inline void PongRequest::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:tunnelbroker.PongRequest.userId) } inline void PongRequest::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:tunnelbroker.PongRequest.userId) } inline std::string* PongRequest::_internal_mutable_userid() { return userid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* PongRequest::release_userid() { // @@protoc_insertion_point(field_release:tunnelbroker.PongRequest.userId) return userid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void PongRequest::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:tunnelbroker.PongRequest.userId) } // string deviceToken = 2; inline void PongRequest::clear_devicetoken() { devicetoken_.ClearToEmpty(); } inline const std::string& PongRequest::devicetoken() const { // @@protoc_insertion_point(field_get:tunnelbroker.PongRequest.deviceToken) return _internal_devicetoken(); } inline void PongRequest::set_devicetoken(const std::string& value) { _internal_set_devicetoken(value); // @@protoc_insertion_point(field_set:tunnelbroker.PongRequest.deviceToken) } inline std::string* PongRequest::mutable_devicetoken() { // @@protoc_insertion_point(field_mutable:tunnelbroker.PongRequest.deviceToken) return _internal_mutable_devicetoken(); } inline const std::string& PongRequest::_internal_devicetoken() const { return devicetoken_.Get(); } inline void PongRequest::_internal_set_devicetoken(const std::string& value) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } inline void PongRequest::set_devicetoken(std::string&& value) { devicetoken_.Set( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:tunnelbroker.PongRequest.deviceToken) } inline void PongRequest::set_devicetoken(const char* value) { GOOGLE_DCHECK(value != nullptr); devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:tunnelbroker.PongRequest.deviceToken) } inline void PongRequest::set_devicetoken(const char* value, size_t size) { devicetoken_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:tunnelbroker.PongRequest.deviceToken) } inline std::string* PongRequest::_internal_mutable_devicetoken() { return devicetoken_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* PongRequest::release_devicetoken() { // @@protoc_insertion_point(field_release:tunnelbroker.PongRequest.deviceToken) return devicetoken_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void PongRequest::set_allocated_devicetoken(std::string* devicetoken) { if (devicetoken != nullptr) { } else { } devicetoken_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), devicetoken, GetArena()); // @@protoc_insertion_point(field_set_allocated:tunnelbroker.PongRequest.deviceToken) } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // @@protoc_insertion_point(namespace_scope) } // namespace tunnelbroker PROTOBUF_NAMESPACE_OPEN template <> struct is_proto_enum< ::tunnelbroker::NewSessionRequest_DeviceTypes> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::tunnelbroker::NewSessionRequest_DeviceTypes>() { return ::tunnelbroker::NewSessionRequest_DeviceTypes_descriptor(); } template <> struct is_proto_enum< ::tunnelbroker::CheckResponseType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::tunnelbroker::CheckResponseType>() { return ::tunnelbroker::CheckResponseType_descriptor(); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tunnelbroker_2eproto diff --git a/shared/protos/identity.proto b/shared/protos/identity.proto index f19e90951..36610e688 100644 --- a/shared/protos/identity.proto +++ b/shared/protos/identity.proto @@ -1,140 +1,155 @@ syntax = "proto3"; package identity; service IdentityService { // 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) {} + // Called by keyservers to get the public key corresponding to a given user ID + // and device ID + rpc GetUserPublicKey(GetUserPublicKeyRequest) returns + (GetUserPublicKeyResponse) {} } // Helper types message PakeRegistrationRequestAndUserID { string userID = 1; string deviceID = 2; // Message sent to initiate PAKE registration (step 1) bytes pakeRegistrationRequest = 3; string username = 4; string userPublicKey = 5; } message PakeCredentialRequestAndUserID { string userID = 1; string deviceID = 2; // Message sent to initiate PAKE login (step 1) bytes pakeCredentialRequest = 3; string userPublicKey = 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; string deviceID = 2; string siweMessage = 3; bytes siweSignature = 4; string userPublicKey = 5; } message WalletLoginResponse { string accessToken = 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; string deviceID = 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; } + +// GetUserPublicKey + +message GetUserPublicKeyRequest { + string userID = 1; + string deviceID = 2; +} + +message GetUserPublicKeyResponse { + string publicKey = 1; +}