Struct redact_crypto::Entry

pub struct Entry<T> {
    pub path: EntryPath,
    pub builder: TypeBuilder,
    pub value: State,
    // some fields omitted
}

Fields

path: EntryPath

builder: TypeBuilder

value: State

Implementations

impl<T: ToSymmetricByteAlgorithm + StorableType> Entry<T>

pub async fn to_symmetric_byte_algorithm(
    self,
    nonce: Option<<T as ToSymmetricByteAlgorithm>::Nonce>
) -> Result<ByteAlgorithm, CryptoError>

impl<T: ToSecretAsymmetricByteAlgorithm + StorableType> Entry<T>

pub async fn to_secret_asymmetric_byte_algorithm(
    self,
    public_key: Option<Entry<<T as ToSecretAsymmetricByteAlgorithm>::PublicKey>>,
    nonce: Option<<T as ToSecretAsymmetricByteAlgorithm>::Nonce>
) -> Result<ByteAlgorithm, CryptoError>

impl<T: ToPublicAsymmetricByteAlgorithm + StorableType> Entry<T>

pub async fn to_public_asymmetric_byte_algorithm(
    self,
    secret_key: Entry<<T as ToPublicAsymmetricByteAlgorithm>::SecretKey>,
    nonce: Option<<T as ToPublicAsymmetricByteAlgorithm>::Nonce>
) -> Result<ByteAlgorithm, CryptoError>

impl<T: StorableType> Entry<T>

pub fn cast<U: StorableType>(self) -> Result<Entry<U>, CryptoError>

pub fn new(path: EntryPath, builder: TypeBuilder, value: State) -> Self

pub fn dereference(
    self
) -> Pin<Box<dyn Future<Output = Result<Entry<T>, CryptoError>> + Send>>

pub fn take_resolve(
    self
) -> Pin<Box<dyn Future<Output = Result<T, CryptoError>> + Send>>

pub fn take_resolve_all(
    self
) -> Pin<Box<dyn Future<Output = Result<(T, EntryPath, State), CryptoError>> + Send>>

pub async fn resolve(&self) -> Result<&T, CryptoError>

Trait Implementations

impl<T: Debug> Debug for Entry<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Entry<T> where
    T: StorableType, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Entry<T> where
    T: StorableType, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.