Context

gpgme

Struct Context 

Source 
pub struct Context(/* private fields */);
Expand description

A context for cryptographic operations.

Upstream documentation: gpgme_ctx_t

Implementations§

Source§

impl Context

Source

pub unsafe fn from_raw(raw: gpgme_ctx_t) -> Self

Source

pub fn as_raw(&self) -> gpgme_ctx_t

Source

pub fn into_raw(self) -> gpgme_ctx_t

Source

pub fn from_protocol(proto: Protocol) -> Result<Self>

Creates a new context and initializes it to work with the specified protocol.

Upstream documentation: gpgme_new and gpgme_set_protocol

Source

pub fn protocol(&self) -> Protocol

Upstream documentation: gpgme_get_protocol

Source

pub fn armor(&self) -> bool

Upstream documentation: gpgme_get_armor

Source

pub fn set_armor(&mut self, enabled: bool)

Upstream documentation: gpgme_set_armor

Source

pub fn text_mode(&self) -> bool

Upstream documentation: gpgme_get_textmode

Source

pub fn set_text_mode(&mut self, enabled: bool)

Upstream documentation: gpgme_set_textmode

Source

pub fn offline(&self) -> bool

Upstream documentation: gpgme_get_offline

Source

pub fn set_offline(&mut self, enabled: bool)

Upstream documentation: gpgme_set_offline

Source

pub fn get_flag( &self, name: impl CStrArgument, ) -> Result<&str, Option<Utf8Error>>

Upstream documentation: gpgme_get_ctx_flag

Source

pub fn get_flag_raw(&self, name: impl CStrArgument) -> Option<&CStr>

Upstream documentation: gpgme_get_ctx_flag

Source

pub fn set_flag( &mut self, name: impl CStrArgument, value: impl CStrArgument, ) -> Result<()>

Upstream documentation: gpgme_set_ctx_flag

Source

pub fn engine_info(&self) -> EngineInfo<'_>

Upstream documentation: gpgme_ctx_get_engine_info

Source

pub fn set_engine_path(&mut self, path: impl CStrArgument) -> Result<()>

Source

pub fn set_engine_home_dir(&mut self, home_dir: impl CStrArgument) -> Result<()>

Source

pub fn set_engine_info( &mut self, path: Option<impl CStrArgument>, home_dir: Option<impl CStrArgument>, ) -> Result<()>

Upstream documentation: gpgme_ctx_set_engine_info

Source

pub fn pinentry_mode(&self) -> PinentryMode

Upstream documentation: gpgme_get_pinentry_mode

Source

pub fn set_pinentry_mode(&mut self, mode: PinentryMode) -> Result<()>

Upstream documentation: gpgme_set_pinentry_mode

Source

pub fn clear_passphrase_provider(&mut self)

Upstream documentation: gpgme_set_passphrase_cb

Source

pub fn set_passphrase_provider<'a, P>( self, provider: P, ) -> ContextWithCallbacks<'a>
where P: PassphraseProvider + 'a,

Upstream documentation: gpgme_set_passphrase_cb

Source

pub fn with_passphrase_provider<R, P>( &mut self, provider: P, f: impl FnOnce(&mut Context) -> R, ) -> R
where P: PassphraseProvider,

Uses the specified provider to handle passphrase requests for the duration of the closure.

Upstream documentation: gpgme_set_passphrase_cb

§Examples
use std::io::prelude::*;

use gpgme::{Context, PassphraseRequest, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
ctx.with_passphrase_provider(|_: PassphraseRequest, out: &mut dyn Write| {
    out.write_all(b"some passphrase")?;
    Ok(())
}, |mut ctx| {
    // Do something with ctx requiring a passphrase, for example decryption
});
Source

pub fn clear_progress_reporter(&mut self)

Upstream documentation: gpgme_set_progress_cb

Source

pub fn set_progress_reporter<'a, P>( self, reporter: P, ) -> ContextWithCallbacks<'a>
where P: ProgressReporter + 'a,

Upstream documentation: gpgme_set_progress_cb

Source

pub fn with_progress_reporter<R, H>( &mut self, handler: H, f: impl FnOnce(&mut Context) -> R, ) -> R
where H: ProgressReporter,

Upstream documentation: gpgme_set_progress_cb

Source

pub fn clear_status_handler(&mut self)

Upstream documentation: gpgme_set_status_cb

Source

pub fn set_status_handler<'a, H>(self, handler: H) -> ContextWithCallbacks<'a>
where H: StatusHandler + 'a,

Upstream documentation: gpgme_set_status_cb

Source

pub fn with_status_handler<R, H>( &mut self, handler: H, f: impl FnOnce(&mut Context) -> R, ) -> R
where H: StatusHandler,

Upstream documentation: gpgme_set_status_cb

Source

pub fn key_list_mode(&self) -> KeyListMode

Upstream documentation: gpgme_get_keylist_mode

Source

pub fn add_key_list_mode(&mut self, mask: KeyListMode) -> Result<()>

Adds all flags set in the provided key listing mode to the Context’s current mode.

Upstream documentation: gpgme_set_keylist_mode

Source

pub fn set_key_list_mode(&mut self, mode: KeyListMode) -> Result<()>

Upstream documentation: gpgme_set_keylist_mode

Source

pub fn keys(&mut self) -> Result<Keys<'_>>

Returns an iterator over all public keys available in the keyring.

Source

pub fn secret_keys(&mut self) -> Result<Keys<'_>>

Returns an iterator over all secret keys available in the keyring.

Source

pub fn refresh_key(&mut self, key: &Key) -> Result<Key>

Returns an updated version of the provided key.

Source

pub fn get_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Returns the public key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.

Upstream documentation: gpgme_get_key

Source

pub fn get_secret_key(&mut self, fpr: impl CStrArgument) -> Result<Key>

Returns the secret key with the specified fingerprint, if such a key can be found. Otherwise, an error is returned.

Upstream documentation: gpgme_get_key

Source

pub fn locate_key(&mut self, email: impl CStrArgument) -> Result<Key>

Source

pub fn find_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>>
where I: IntoIterator, I::Item: CStrArgument,

Returns an iterator over a list of all public keys matching one or more of the specified patterns.

Upstream documentation: gpgme_op_keylist_ext_start

Source

pub fn find_secret_keys<I>(&mut self, patterns: I) -> Result<Keys<'_>>
where I: IntoIterator, I::Item: CStrArgument,

Returns an iterator over a list of all secret keys matching one or more of the specified patterns.

Upstream documentation: gpgme_op_keylist_ext_start

Source

pub fn read_keys<'s, 'd, D>(&'s mut self, src: D) -> Result<Keys<'d, D::Output>>
where D: IntoData<'d>, 's: 'd,

Returns an iterator over the keys encoded in the specified source.

Upstream documentation: gpgme_op_keylist_from_data_start

§Examples
use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let mut keyring = Data::load("somefile")?;
for key in ctx.read_keys(&mut keyring)? {
    println!("{:?}", key);
}
Source

pub fn generate_key<'d1, 'd2, D1, D2>( &mut self, params: impl CStrArgument, public: Option<D1>, secret: Option<D2>, ) -> Result<KeyGenerationResult>
where D1: IntoData<'d1>, D2: IntoData<'d2>,

Upstream documentation: gpgme_op_genkey

Source

pub fn create_key( &mut self, userid: impl CStrArgument, algo: impl CStrArgument, expires: Duration, ) -> Result<KeyGenerationResult>

Creates a new OpenPGP key.

Upstream documentation: gpgme_op_createkey

§Examples
use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let result = ctx.create_key("Example User <example@example.com>", "default", Default::default())?;
println!("Key Fingerprint: {}", result.fingerprint().unwrap());
Source

pub fn create_key_with_flags( &mut self, userid: impl CStrArgument, algo: impl CStrArgument, expires: Duration, flags: CreateKeyFlags, ) -> Result<KeyGenerationResult>

Upstream documentation: gpgme_op_createkey

Source

pub fn create_subkey( &mut self, key: &Key, algo: impl CStrArgument, expires: Duration, ) -> Result<KeyGenerationResult>

Upstream documentation: gpgme_op_createsubkey

Source

pub fn create_subkey_with_flags( &mut self, key: &Key, algo: impl CStrArgument, expires: Duration, flags: CreateKeyFlags, ) -> Result<KeyGenerationResult>

Upstream documentation: gpgme_op_createsubkey

Source

pub fn set_expire_all(&mut self, key: &Key, expires: Duration) -> Result<()>

Upstream documentation: gpgme_op_setexpire

Source

pub fn set_expire<I>( &mut self, key: &Key, expires: Duration, subkeys: I, ) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Upstream documentation: gpgme_op_setexpire

Source

pub fn add_uid(&mut self, key: &Key, userid: impl CStrArgument) -> Result<()>

Upstream documentation: gpgme_op_adduid

Source

pub fn revoke_uid(&mut self, key: &Key, userid: impl CStrArgument) -> Result<()>

Upstream documentation: gpgme_op_revuid

Source

pub fn set_uid_flag( &mut self, key: &Key, userid: impl CStrArgument, name: impl CStrArgument, value: Option<impl CStrArgument>, ) -> Result<()>

Upstream documentation: gpgme_op_set_uid_flag

Source

pub fn set_primary_uid( &mut self, key: &Key, userid: impl CStrArgument, ) -> Result<()>

Source

pub fn sign_key<I>( &mut self, key: &Key, userids: I, expires: Duration, ) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Signs the given key with the default signing key, or the keys specified via add_signer.

Upstream documentation: gpgme_op_keysign

Source

pub fn sign_key_with_flags<I>( &mut self, key: &Key, userids: I, expires: Duration, flags: KeySigningFlags, ) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Signs the given key with the default signing key, or the keys specified via add_signer.

Upstream documentation: gpgme_op_keysign

Source

pub fn revoke_signature<I>( &mut self, key: &Key, signing_key: &Key, userids: I, ) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Upstream documentation: gpgme_op_revsig

Source

pub fn change_key_tofu_policy( &mut self, key: &Key, policy: TofuPolicy, ) -> Result<()>

Upstream documentation: gpgme_op_tofu_policy

Source

pub fn change_key_passphrase(&mut self, key: &Key) -> Result<()>

Upstream documentation: gpgme_op_passwd

Source

pub fn edit_key<'a, E, D>( &mut self, key: &Key, interactor: E, data: D, ) -> Result<()>
where E: EditInteractor, D: IntoData<'a>,

👎Deprecated since 0.9.2: use interact instead

Upstream documentation: gpgme_op_edit

Source

pub fn edit_card_key<'a, E, D>( &mut self, key: &Key, interactor: E, data: D, ) -> Result<()>
where E: EditInteractor, D: IntoData<'a>,

👎Deprecated since 0.9.2: use interact_with_card instead

Upstream documentation: gpgme_op_card_edit

Source

pub fn edit_key_with<'a, D>( &mut self, key: &Key, editor: impl Editor, data: D, ) -> Result<()>
where D: IntoData<'a>,

👎Deprecated since 0.9.2: use interact instead

Upstream documentation: gpgme_op_edit

Source

pub fn edit_card_key_with<'a, D>( &mut self, key: &Key, editor: impl Editor, data: D, ) -> Result<()>
where D: IntoData<'a>,

👎Deprecated since 0.9.2: use interact_with_card instead

Upstream documentation: gpgme_op_card_edit

Source

pub fn interact<'a, I, D>( &mut self, key: &Key, interactor: I, data: D, ) -> Result<()>
where I: Interactor, D: IntoData<'a>,

Upstream documentation: gpgme_op_interact

Source

pub fn interact_with_card<'a, I, D>( &mut self, key: &Key, interactor: I, data: D, ) -> Result<()>
where I: Interactor, D: IntoData<'a>,

Upstream documentation: gpgme_op_interact

Source

pub fn interact_with_flags<'a, I, D>( &mut self, key: Option<&Key>, interactor: I, data: D, flags: InteractFlags, ) -> Result<()>
where I: Interactor, D: IntoData<'a>,

Upstream documentation: gpgme_op_interact

Source

pub fn delete_key(&mut self, key: &Key) -> Result<()>

Upstream documentation: gpgme_op_delete

Source

pub fn delete_secret_key(&mut self, key: &Key) -> Result<()>

Upstream documentation: gpgme_op_delete

Source

pub fn delete_key_with_flags( &mut self, key: &Key, flags: DeleteKeyFlags, ) -> Result<()>

Upstream documentation: gpgme_op_delete_ext

Source

pub fn import<'a, D>(&mut self, src: D) -> Result<ImportResult>
where D: IntoData<'a>,

Upstream documentation: gpgme_op_import

Source

pub fn import_keys<'k, I>(&mut self, keys: I) -> Result<ImportResult>
where I: IntoIterator<Item = &'k Key>,

Upstream documentation: gpgme_op_import_keys

Source

pub fn import_remote_keys<I>(&mut self, uids: I) -> Result<ImportResult>
where I: IntoIterator, I::Item: CStrArgument,

Upstream documentation: gpgme_op_receive_keys

Source

pub fn export_all_extern<I>(&mut self, mode: ExportMode) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Upstream documentation: gpgme_op_export_ext

Source

pub fn export_extern<I>(&mut self, patterns: I, mode: ExportMode) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument,

Upstream documentation: gpgme_op_export_ext

Source

pub fn export_all<'a, D>(&mut self, mode: ExportMode, dst: D) -> Result<()>
where D: IntoData<'a>,

Upstream documentation: gpgme_op_export_ext

Source

pub fn export<'a, I, D>( &mut self, patterns: I, mode: ExportMode, dst: D, ) -> Result<()>
where I: IntoIterator, I::Item: CStrArgument, D: IntoData<'a>,

Upstream documentation: gpgme_op_export_ext

Source

pub fn export_keys_extern<'k, I>( &mut self, keys: I, mode: ExportMode, ) -> Result<()>
where I: IntoIterator<Item = &'k Key>,

Upstream documentation: gpgme_op_export_keys

Source

pub fn export_keys<'k, 'a, I, D>( &mut self, keys: I, mode: ExportMode, dst: D, ) -> Result<()>
where I: IntoIterator<Item = &'k Key>, D: IntoData<'a>,

Upstream documentation: gpgme_op_export_keys

Source

pub fn clear_sender(&mut self) -> Result<()>

Upstream documentation: gpgme_set_sender

Source

pub fn set_sender(&mut self, sender: impl CStrArgument) -> Result<()>

Upstream documentation: gpgme_set_sender

Source

pub fn sender(&self) -> Result<&str, Option<Utf8Error>>

Upstream documentation: gpgme_get_sender

Source

pub fn sender_raw(&self) -> Option<&CStr>

Upstream documentation: gpgme_get_sender

Source

pub fn clear_signers(&mut self)

Upstream documentation: gpgme_signers_clear

Source

pub fn add_signer(&mut self, key: &Key) -> Result<()>

Upstream documentation: gpgme_signers_add

Source

pub fn signers(&self) -> Signers<'_> ⓘ

Upstream documentation: gpgme_signers_enum

Source

pub fn clear_signature_notations(&mut self)

Upstream documentation: gpgme_sig_notation_clear

Source

pub fn add_signature_notation( &mut self, name: impl CStrArgument, value: impl CStrArgument, flags: SignatureNotationFlags, ) -> Result<()>

Upstream documentation: gpgme_sig_notation_add

Source

pub fn add_signature_policy_url( &mut self, url: impl CStrArgument, critical: bool, ) -> Result<()>

Upstream documentation: gpgme_sig_notation_add

Source

pub fn signature_policy_url(&self) -> Result<&str, Option<Utf8Error>>

Upstream documentation: gpgme_sig_notation_get

Source

pub fn signature_policy_url_raw(&self) -> Option<&CStr>

Upstream documentation: gpgme_sig_notation_get

Source

pub fn signature_notations(&self) -> SignatureNotations<'_> ⓘ

Upstream documentation: gpgme_sig_notation_get

Source

pub fn sign_clear<'p, 't, P, T>( &mut self, plaintext: P, signedtext: T, ) -> Result<SigningResult>
where P: IntoData<'p>, T: IntoData<'t>,

Creates a clear text signature.

Upstream documentation: gpgme_op_sign

Source

pub fn sign_detached<'p, 's, P, S>( &mut self, plaintext: P, signature: S, ) -> Result<SigningResult>
where P: IntoData<'p>, S: IntoData<'s>,

Creates a detached signature.

Upstream documentation: gpgme_op_sign

Source

pub fn sign_normal<'p, 't, P, T>( &mut self, plaintext: P, signedtext: T, ) -> Result<SigningResult>
where P: IntoData<'p>, T: IntoData<'t>,

Creates a normal signature.

Upstream documentation: gpgme_op_sign

Source

pub fn sign<'p, 's, P, S>( &mut self, mode: SignMode, plaintext: P, signature: S, ) -> Result<SigningResult>
where P: IntoData<'p>, S: IntoData<'s>,

Creates a signature for the text stored in the data object plaintext and writes it to the data object signature.

The type of the signature created is determined by the ASCII armor (or, if that is not set, by the encoding specified for sig), the text mode attributes set for the context and the requested signature mode.

Information about the results of the operation are returned in the SigningResult structure.

Upstream documentation: gpgme_op_sign

Source

pub fn verify_detached<'s, 't, S, T>( &mut self, signature: S, signedtext: T, ) -> Result<VerificationResult>
where S: IntoData<'s>, T: IntoData<'t>,

Upstream documentation: gpgme_op_verify

Source

pub fn verify_opaque<'s, 'p, S, P>( &mut self, signedtext: S, plaintext: P, ) -> Result<VerificationResult>
where S: IntoData<'s>, P: IntoData<'p>,

Upstream documentation: gpgme_op_verify

Source

pub fn encrypt<'k, 'p, 'c, I, P, C>( &mut self, recp: I, plaintext: P, ciphertext: C, ) -> Result<EncryptionResult>
where I: IntoIterator<Item = &'k Key>, P: IntoData<'p>, C: IntoData<'c>,

Encrypts a message for the specified recipients.

Upstream documentation: gpgme_op_encrypt

§Examples
use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let key = ctx.get_key("[some key fingerprint]")?;
let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new());
ctx.encrypt(Some(&key), plaintext, &mut ciphertext)?;
Source

pub fn encrypt_with_flags<'k, 'p, 'c, I, P, C>( &mut self, recp: I, plaintext: P, ciphertext: C, flags: EncryptFlags, ) -> Result<EncryptionResult>
where I: IntoIterator<Item = &'k Key>, P: IntoData<'p>, C: IntoData<'c>,

Upstream documentation: gpgme_op_encrypt

Source

pub fn encrypt_symmetric<'p, 'c, P, C>( &mut self, plaintext: P, ciphertext: C, ) -> Result<()>
where P: IntoData<'p>, C: IntoData<'c>,

Upstream documentation: gpgme_op_encrypt

Source

pub fn encrypt_symmetric_with_flags<'p, 'c, P, C>( &mut self, plaintext: P, ciphertext: C, flags: EncryptFlags, ) -> Result<()>
where P: IntoData<'p>, C: IntoData<'c>,

Upstream documentation: gpgme_op_encrypt

Source

pub fn sign_and_encrypt<'k, 'p, 'c, I, P, C>( &mut self, recp: I, plaintext: P, ciphertext: C, ) -> Result<(EncryptionResult, SigningResult)>
where I: IntoIterator<Item = &'k Key>, P: IntoData<'p>, C: IntoData<'c>,

Encrypts and signs a message for the specified recipients.

Upstream documentation: gpgme_op_encrypt_sign

§Examples
use gpgme::{Context, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let key = ctx.get_key("[some key fingerprint]")?;
let (plaintext, mut ciphertext) = ("Hello, World!", Vec::new());
ctx.sign_and_encrypt(Some(&key), plaintext, &mut ciphertext)?;
Source

pub fn sign_and_encrypt_with_flags<'k, 'p, 'c, I, P, C>( &mut self, recp: I, plaintext: P, ciphertext: C, flags: EncryptFlags, ) -> Result<(EncryptionResult, SigningResult)>
where I: IntoIterator<Item = &'k Key>, P: IntoData<'p>, C: IntoData<'c>,

Upstream documentation: gpgme_op_encrypt_sign

Source

pub fn decrypt<'c, 'p, C, P>( &mut self, ciphertext: C, plaintext: P, ) -> Result<DecryptionResult>
where C: IntoData<'c>, P: IntoData<'p>,

Decrypts a message.

Upstream documentation: gpgme_op_decrypt

§Examples
use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let mut cipher = Data::load("some file")?;
let mut plain = Vec::new();
ctx.decrypt(&mut cipher, &mut plain)?;
Source

pub fn decrypt_with_flags<'c, 'p, C, P>( &mut self, ciphertext: C, plaintext: P, flags: DecryptFlags, ) -> Result<DecryptionResult>
where C: IntoData<'c>, P: IntoData<'p>,

Upstream documentation: gpgme_op_decrypt_ext

Source

pub fn decrypt_and_verify<'c, 'p, C, P>( &mut self, ciphertext: C, plaintext: P, ) -> Result<(DecryptionResult, VerificationResult)>
where C: IntoData<'c>, P: IntoData<'p>,

Decrypts and verifies a message.

Upstream documentation: gpgme_op_decrypt_verify

§Examples
use gpgme::{Context, Data, Protocol};

let mut ctx = Context::from_protocol(Protocol::OpenPgp)?;
let mut cipher = Data::load("some file")?;
let mut plain = Vec::new();
ctx.decrypt_and_verify(&mut cipher, &mut plain)?;
Source

pub fn decrypt_and_verify_with_flags<'c, 'p, C, P>( &mut self, ciphertext: C, plaintext: P, flags: DecryptFlags, ) -> Result<(DecryptionResult, VerificationResult)>
where C: IntoData<'c>, P: IntoData<'p>,

Upstream documentation: gpgme_op_decrypt_ext

Source

pub fn query_swdb( &mut self, name: Option<impl CStrArgument>, installed_ver: Option<impl CStrArgument>, ) -> Result<QuerySwdbResult>

Upstream documentation: gpgme_op_query_swdb

Source

pub fn get_audit_log<'a, D>( &mut self, dst: D, flags: AuditLogFlags, ) -> Result<()>
where D: IntoData<'a>,

Upstream documentation: gpgme_op_getauditlog

Trait Implementations§

Source§

impl Debug for Context

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Drop for Context

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

impl From<Context> for ContextWithCallbacks<'_>

Source§

fn from(inner: Context) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<Src, Scheme> ApproxFrom<Src, Scheme> for Src
where Scheme: ApproxScheme,

Source§

type Err = NoError

The error type produced by a failed conversion.
Source§

fn approx_from(src: Src) -> Result<Src, <Src as ApproxFrom<Src, Scheme>>::Err>

Convert the given value into an approximately equivalent representation.
Source§

impl<Dst, Src, Scheme> ApproxInto<Dst, Scheme> for Src
where Dst: ApproxFrom<Src, Scheme>, Scheme: ApproxScheme,

Source§

type Err = <Dst as ApproxFrom<Src, Scheme>>::Err

The error type produced by a failed conversion.
Source§

fn approx_into(self) -> Result<Dst, <Src as ApproxInto<Dst, Scheme>>::Err>

Convert the subject into an approximately equivalent representation.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T, Dst> ConvAsUtil<Dst> for T

Source§

fn approx(self) -> Result<Dst, Self::Err>
where Self: Sized + ApproxInto<Dst>,

Approximate the subject with the default scheme.
Source§

fn approx_by<Scheme>(self) -> Result<Dst, Self::Err>
where Self: Sized + ApproxInto<Dst, Scheme>, Scheme: ApproxScheme,

Approximate the subject with a specific scheme.
Source§

impl<T> ConvUtil for T

Source§

fn approx_as<Dst>(self) -> Result<Dst, Self::Err>
where Self: Sized + ApproxInto<Dst>,

Approximate the subject to a given type with the default scheme.
Source§

fn approx_as_by<Dst, Scheme>(self) -> Result<Dst, Self::Err>
where Self: Sized + ApproxInto<Dst, Scheme>, Scheme: ApproxScheme,

Approximate the subject to a given type with a specific scheme.
Source§

fn into_as<Dst>(self) -> Dst
where Self: Sized + Into<Dst>,

Convert the subject to a given type.
Source§

fn try_as<Dst>(self) -> Result<Dst, Self::Err>
where Self: Sized + TryInto<Dst>,

Attempt to convert the subject to a given type.
Source§

fn value_as<Dst>(self) -> Result<Dst, Self::Err>
where Self: Sized + ValueInto<Dst>,

Attempt a value conversion of the subject to a given type.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<Src> TryFrom<Src> for Src

Source§

type Err = NoError

The error type produced by a failed conversion.
Source§

fn try_from(src: Src) -> Result<Src, <Src as TryFrom<Src>>::Err>

Convert the given value into the subject type.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<Src, Dst> TryInto<Dst> for Src
where Dst: TryFrom<Src>,

Source§

type Err = <Dst as TryFrom<Src>>::Err

The error type produced by a failed conversion.
Source§

fn try_into(self) -> Result<Dst, <Src as TryInto<Dst>>::Err>

Convert the subject into the destination type.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<Src> ValueFrom<Src> for Src

Source§

type Err = NoError

The error type produced by a failed conversion.
Source§

fn value_from(src: Src) -> Result<Src, <Src as ValueFrom<Src>>::Err>

Convert the given value into an exactly equivalent representation.
Source§

impl<Src, Dst> ValueInto<Dst> for Src
where Dst: ValueFrom<Src>,

Source§

type Err = <Dst as ValueFrom<Src>>::Err

The error type produced by a failed conversion.
Source§

fn value_into(self) -> Result<Dst, <Src as ValueInto<Dst>>::Err>

Convert the subject into an exactly equivalent representation.