Struct E2eiEnrollment

pub struct E2eiEnrollment(/* private fields */);

See core_crypto::e2e_identity::E2eiEnrollment

Implementations

impl E2eiEnrollment

pub fn new(inner: E2eiEnrollment) -> Self

pub fn into_inner(self) -> Option<E2eiEnrollment>

impl E2eiEnrollment

pub async fn directory_response( &self, directory: Vec<u8>, ) -> CoreCryptoResult<AcmeDirectory>

See core_crypto::e2e_identity::E2eiEnrollment::directory_response

pub async fn new_account_request( &self, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::new_account_request

pub async fn new_account_response( &self, account: Vec<u8>, ) -> CoreCryptoResult<()>

See core_crypto::e2e_identity::E2eiEnrollment::new_account_response

pub async fn new_order_request( &self, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::new_order_request

pub async fn new_order_response( &self, order: Vec<u8>, ) -> CoreCryptoResult<NewAcmeOrder>

See core_crypto::e2e_identity::E2eiEnrollment::new_order_response

pub async fn new_authz_request( &self, url: String, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::new_authz_request

pub async fn new_authz_response( &self, authz: Vec<u8>, ) -> CoreCryptoResult<NewAcmeAuthz>

See core_crypto::e2e_identity::E2eiEnrollment::new_authz_response

pub async fn create_dpop_token( &self, expiry_secs: u32, backend_nonce: String, ) -> CoreCryptoResult<String>

See core_crypto::e2e_identity::E2eiEnrollment::create_dpop_token

pub async fn new_dpop_challenge_request( &self, access_token: String, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::new_dpop_challenge_request

pub async fn new_dpop_challenge_response( &self, challenge: Vec<u8>, ) -> CoreCryptoResult<()>

See core_crypto::e2e_identity::E2eiEnrollment::new_dpop_challenge_response

pub async fn check_order_request( &self, order_url: String, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::check_order_request

pub async fn check_order_response( &self, order: Vec<u8>, ) -> CoreCryptoResult<String>

See core_crypto::e2e_identity::E2eiEnrollment::check_order_response

pub async fn finalize_request( &self, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::prelude::E2eiEnrollment::finalize_request

pub async fn finalize_response( &self, finalize: Vec<u8>, ) -> CoreCryptoResult<String>

See core_crypto::prelude::E2eiEnrollment::finalize_response

pub async fn certificate_request( &self, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::prelude::E2eiEnrollment::certificate_request

impl E2eiEnrollment

pub async fn new_oidc_challenge_request( &self, id_token: String, refresh_token: String, previous_nonce: String, ) -> CoreCryptoResult<Vec<u8>>

See core_crypto::e2e_identity::E2eiEnrollment::new_oidc_challenge_request

pub async fn new_oidc_challenge_response( &self, cc: Arc<CoreCryptoContext>, challenge: Vec<u8>, ) -> CoreCryptoResult<()>

See core_crypto::e2e_identity::E2eiEnrollment::new_oidc_challenge_response

pub async fn get_refresh_token(&self) -> CoreCryptoResult<String>

See core_crypto::prelude::E2eiEnrollment::get_refresh_token

Methods from Deref<Target = RwLock<E2eiEnrollment>>

pub fn try_read_arc(self: &Arc<RwLock<T>>) -> Option<RwLockReadGuardArc<T>>

Attempts to acquire an an owned, reference-counted read lock.

If a read lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

let reader = lock.read_arc().await;
assert_eq!(*reader, 1);

assert!(lock.try_read_arc().is_some());

pub fn read_arc<'a>(self: &'a Arc<RwLock<T>>) -> ReadArc<'a, T>

Acquires an owned, reference-counted read lock.

Returns a guard that releases the lock when dropped.

Note that attempts to acquire a read lock will block if there are also concurrent attempts to acquire a write lock.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

let reader = lock.read_arc().await;
assert_eq!(*reader, 1);

assert!(lock.try_read_arc().is_some());

pub fn read_arc_blocking(self: &Arc<RwLock<T>>) -> RwLockReadGuardArc<T>

Acquires an owned, reference-counted read lock.

Returns a guard that releases the lock when dropped.

Note that attempts to acquire a read lock will block if there are also concurrent attempts to acquire a write lock.

Blocking

Rather than using asynchronous waiting, like the [read_arc][RwLock::read_arc] method, this method will block the current thread until the read lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

let reader = lock.read_arc_blocking();
assert_eq!(*reader, 1);

assert!(lock.try_read().is_some());

pub fn try_read(&self) -> Option<RwLockReadGuard<'_, T>>

Attempts to acquire a read lock.

If a read lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

let reader = lock.read().await;
assert_eq!(*reader, 1);

assert!(lock.try_read().is_some());

pub fn read(&self) -> Read<'_, T>

Acquires a read lock.

Returns a guard that releases the lock when dropped.

Note that attempts to acquire a read lock will block if there are also concurrent attempts to acquire a write lock.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

let reader = lock.read().await;
assert_eq!(*reader, 1);

assert!(lock.try_read().is_some());

pub fn read_blocking(&self) -> RwLockReadGuard<'_, T>

Acquires a read lock.

Returns a guard that releases the lock when dropped.

Note that attempts to acquire a read lock will block if there are also concurrent attempts to acquire a write lock.

Blocking

Rather than using asynchronous waiting, like the [read][RwLock::read] method, this method will block the current thread until the read lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

let reader = lock.read_blocking();
assert_eq!(*reader, 1);

assert!(lock.try_read().is_some());

pub fn try_upgradable_read(&self) -> Option<RwLockUpgradableReadGuard<'_, T>>

Attempts to acquire a read lock with the possiblity to upgrade to a write lock.

If a read lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Examples

use async_lock::{RwLock, RwLockUpgradableReadGuard};

let lock = RwLock::new(1);

let reader = lock.upgradable_read().await;
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuard::upgrade(reader).await;
*writer = 2;

pub fn upgradable_read(&self) -> UpgradableRead<'_, T>

Acquires a read lock with the possiblity to upgrade to a write lock.

Returns a guard that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Note that attempts to acquire an upgradable read lock will block if there are concurrent attempts to acquire another upgradable read lock or a write lock.

Examples

use async_lock::{RwLock, RwLockUpgradableReadGuard};

let lock = RwLock::new(1);

let reader = lock.upgradable_read().await;
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuard::upgrade(reader).await;
*writer = 2;

pub fn upgradable_read_blocking(&self) -> RwLockUpgradableReadGuard<'_, T>

Attempts to acquire a read lock with the possiblity to upgrade to a write lock.

Returns a guard that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Note that attempts to acquire an upgradable read lock will block if there are concurrent attempts to acquire another upgradable read lock or a write lock.

Blocking

Rather than using asynchronous waiting, like the [upgradable_read][RwLock::upgradable_read] method, this method will block the current thread until the read lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use async_lock::{RwLock, RwLockUpgradableReadGuard};

let lock = RwLock::new(1);

let reader = lock.upgradable_read_blocking();
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuard::upgrade_blocking(reader);
*writer = 2;

pub fn upgradable_read_arc_blocking( self: &Arc<RwLock<T>>, ) -> RwLockUpgradableReadGuardArc<T>

Attempts to acquire an owned, reference-counted read lock with the possiblity to upgrade to a write lock.

Returns a guard that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Note that attempts to acquire an upgradable read lock will block if there are concurrent attempts to acquire another upgradable read lock or a write lock.

Blocking

Rather than using asynchronous waiting, like the [upgradable_read_arc][RwLock::upgradable_read_arc] method, this method will block the current thread until the read lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use std::sync::Arc;
use async_lock::{RwLock, RwLockUpgradableReadGuardArc};

let lock = Arc::new(RwLock::new(1));

let reader = lock.upgradable_read_arc_blocking();
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuardArc::upgrade_blocking(reader);
*writer = 2;

pub fn try_upgradable_read_arc( self: &Arc<RwLock<T>>, ) -> Option<RwLockUpgradableReadGuardArc<T>>

Attempts to acquire an owned, reference-counted read lock with the possiblity to upgrade to a write lock.

If a read lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Examples

use std::sync::Arc;
use async_lock::{RwLock, RwLockUpgradableReadGuardArc};

let lock = Arc::new(RwLock::new(1));

let reader = lock.upgradable_read_arc().await;
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read_arc().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuardArc::upgrade(reader).await;
*writer = 2;

pub fn upgradable_read_arc<'a>( self: &'a Arc<RwLock<T>>, ) -> UpgradableReadArc<'a, T>

Acquires an owned, reference-counted read lock with the possiblity to upgrade to a write lock.

Returns a guard that releases the lock when dropped.

Upgradable read lock reserves the right to be upgraded to a write lock, which means there can be at most one upgradable read lock at a time.

Note that attempts to acquire an upgradable read lock will block if there are concurrent attempts to acquire another upgradable read lock or a write lock.

Examples

use std::sync::Arc;
use async_lock::{RwLock, RwLockUpgradableReadGuardArc};

let lock = Arc::new(RwLock::new(1));

let reader = lock.upgradable_read_arc().await;
assert_eq!(*reader, 1);
assert_eq!(*lock.try_read_arc().unwrap(), 1);

let mut writer = RwLockUpgradableReadGuardArc::upgrade(reader).await;
*writer = 2;

pub fn try_write(&self) -> Option<RwLockWriteGuard<'_, T>>

Attempts to acquire a write lock.

If a write lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

assert!(lock.try_write().is_some());
let reader = lock.read().await;
assert!(lock.try_write().is_none());

pub fn write(&self) -> Write<'_, T>

Acquires a write lock.

Returns a guard that releases the lock when dropped.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

let writer = lock.write().await;
assert!(lock.try_read().is_none());

pub fn write_blocking(&self) -> RwLockWriteGuard<'_, T>

Acquires a write lock.

Returns a guard that releases the lock when dropped.

Blocking

Rather than using asynchronous waiting, like the write method, this method will block the current thread until the write lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use async_lock::RwLock;

let lock = RwLock::new(1);

let writer = lock.write_blocking();
assert!(lock.try_read().is_none());

pub fn try_write_arc(self: &Arc<RwLock<T>>) -> Option<RwLockWriteGuardArc<T>>

Attempts to acquire an owned, reference-counted write lock.

If a write lock could not be acquired at this time, then None is returned. Otherwise, a guard is returned that releases the lock when dropped.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

assert!(lock.try_write_arc().is_some());
let reader = lock.read_arc().await;
assert!(lock.try_write_arc().is_none());

pub fn write_arc<'a>(self: &'a Arc<RwLock<T>>) -> WriteArc<'a, T>

Acquires an owned, reference-counted write lock.

Returns a guard that releases the lock when dropped.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

let writer = lock.write_arc().await;
assert!(lock.try_read_arc().is_none());

pub fn write_arc_blocking(self: &Arc<RwLock<T>>) -> RwLockWriteGuardArc<T>

Acquires an owned, reference-counted write lock.

Returns a guard that releases the lock when dropped.

Blocking

Rather than using asynchronous waiting, like the [write_arc][RwLock::write_arc] method, this method will block the current thread until the write lock is acquired.

This method should not be used in an asynchronous context. It is intended to be used in a way that a lock can be used in both asynchronous and synchronous contexts. Calling this method in an asynchronous context may result in a deadlock.

Examples

use std::sync::Arc;
use async_lock::RwLock;

let lock = Arc::new(RwLock::new(1));

let writer = lock.write_arc_blocking();
assert!(lock.try_read().is_none());

Trait Implementations

impl Debug for E2eiEnrollment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for E2eiEnrollment

type Target = RwLock<E2eiEnrollment>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<UT> LiftRef<UT> for E2eiEnrollment

type LiftType = Arc<E2eiEnrollment>

impl<UT> LowerError<UT> for E2eiEnrollment

fn lower_error(obj: Self) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for E2eiEnrollment

type ReturnType = <Arc<E2eiEnrollment> as LowerReturn<UniFfiTag>>::ReturnType

The type that should be returned by scaffolding functions for this type.

fn lower_return(obj: Self) -> Result<Self::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl<UT> TypeId<UT> for E2eiEnrollment

const TYPE_ID_META: MetadataBuffer