Struct KeyAmalgamation 

pub struct KeyAmalgamation<'a, P, R, R2>
where
    P: 'a + KeyParts,
    R: 'a + KeyRole,
{ /* private fields */ }

A key, and its associated data, and useful methods.

A KeyAmalgamation is like a ComponentAmalgamation, but specialized for keys. Due to the requirement to keep track of the key’s role when it is erased (see the module’s documentation for more details), this is a different data structure rather than a specialized type alias.

Generally, you won’t use this type directly, but instead use PrimaryKeyAmalgamation, SubordinateKeyAmalgamation, or ErasedKeyAmalgamation.

A KeyAmalgamation is returned by Cert::primary_key, and Cert::keys.

KeyAmalgamation implements ValidateAmalgamation, which allows you to turn a KeyAmalgamation into a ValidKeyAmalgamation using KeyAmalgamation::with_policy.

Examples

Iterating over all keys:

for ka in cert.keys() {
    let ka: ErasedKeyAmalgamation<_> = ka;
}

Getting the primary key:

let ka: PrimaryKeyAmalgamation<_> = cert.primary_key();

Iterating over just the subkeys:

// We can skip the primary key (it's always first):
for ka in cert.keys().skip(1) {
    let ka: ErasedKeyAmalgamation<_> = ka;
}

// Or use `subkeys`, which returns a more accurate type:
for ka in cert.keys().subkeys() {
    let ka: SubordinateKeyAmalgamation<_> = ka;
}

Implementations

impl<'a, P> KeyAmalgamation<'a, P, PrimaryRole, ()>

where P: KeyParts,

pub fn parts_into_public(self) -> PrimaryKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public(&'a self) -> &'a PrimaryKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public_mut( &'a mut self, ) -> &'a mut PrimaryKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_into_secret( self, ) -> Result<PrimaryKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret( &'a self, ) -> Result<&'a PrimaryKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret_mut( &'a mut self, ) -> Result<&'a mut PrimaryKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_into_unspecified( self, ) -> PrimaryKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified( &'a self, ) -> &'a PrimaryKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified_mut( &'a mut self, ) -> &'a mut PrimaryKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

impl<'a, P> KeyAmalgamation<'a, P, SubordinateRole, ()>

where P: KeyParts,

pub fn parts_into_public(self) -> SubordinateKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public( &'a self, ) -> &'a SubordinateKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public_mut( &'a mut self, ) -> &'a mut SubordinateKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_into_secret( self, ) -> Result<SubordinateKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret( &'a self, ) -> Result<&'a SubordinateKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret_mut( &'a mut self, ) -> Result<&'a mut SubordinateKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_into_unspecified( self, ) -> SubordinateKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified( &'a self, ) -> &'a SubordinateKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified_mut( &'a mut self, ) -> &'a mut SubordinateKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

impl<'a, P> KeyAmalgamation<'a, P, UnspecifiedRole, bool>

where P: KeyParts,

pub fn parts_into_public(self) -> ErasedKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public(&'a self) -> &'a ErasedKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_as_public_mut( &'a mut self, ) -> &'a mut ErasedKeyAmalgamation<'a, PublicParts>

Changes the key’s parts tag to PublicParts.

pub fn parts_into_secret(self) -> Result<ErasedKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret( &'a self, ) -> Result<&'a ErasedKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_as_secret_mut( &'a mut self, ) -> Result<&'a mut ErasedKeyAmalgamation<'a, SecretParts>>

Changes the key’s parts tag to SecretParts.

pub fn parts_into_unspecified( self, ) -> ErasedKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified( &'a self, ) -> &'a ErasedKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

pub fn parts_as_unspecified_mut( &'a mut self, ) -> &'a mut ErasedKeyAmalgamation<'a, UnspecifiedParts>

Changes the key’s parts tag to UnspecifiedParts.

impl<'a, P> KeyAmalgamation<'a, P, SubordinateRole, ()>

where P: KeyParts,

pub fn revocation_status<T>( &self, policy: &dyn Policy, t: T, ) -> RevocationStatus<'_>

where T: Into<Option<SystemTime>>,

Returns the subkey’s revocation status at time t.

A subkey is revoked at time t if:

• There is a live revocation at time t that is newer than all live self signatures at time t, or

• There is a hard revocation (even if it is not live at time t, and even if there is a newer self-signature).

Note: Certs and subkeys have different criteria from User IDs and User Attributes.

Note: this only returns whether this subkey is revoked; it does not imply anything about the Cert or other components.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display the subkeys' revocation status.
for ka in cert.keys().subkeys() {
    eprintln!(" Revocation status of {}: {:?}",
              ka.key().fingerprint(), ka.revocation_status(p, None));
}

impl<'a, P> KeyAmalgamation<'a, P, PrimaryRole, ()>

where P: KeyParts,

pub fn binding_signature<T>( &self, policy: &dyn Policy, time: T, ) -> Result<&'a Signature>

where T: Into<Option<SystemTime>>,

Returns the active binding signature at time t.

The active binding signature is the most recent, non-revoked self-signature that is valid according to the policy and alive at time t (creation time <= t, t < expiry). If there are multiple such signatures then the signatures are ordered by their MPIs interpreted as byte strings.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display information about the primary key's current active
// binding signature (the `time` parameter is `None`), if any.
eprintln!("{:?}", cert.primary_key().binding_signature(p, None));

impl<'a, P: 'a + KeyParts> KeyAmalgamation<'a, P, SubordinateRole, ()>

pub fn binding_signature<T>( &self, policy: &dyn Policy, time: T, ) -> Result<&'a Signature>

where T: Into<Option<SystemTime>>,

Returns the active binding signature at time t.

The active binding signature is the most recent, non-revoked self-signature that is valid according to the policy and alive at time t (creation time <= t, t < expiry). If there are multiple such signatures then the signatures are ordered by their MPIs interpreted as byte strings.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

// Display information about each keys' current active
// binding signature (the `time` parameter is `None`), if any.
for k in cert.keys().subkeys() {
    eprintln!("{:?}", k.binding_signature(p, None));
}

impl<'a, P, R, R2> KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts, R: 'a + KeyRole,

pub fn cert(&self) -> &'a Cert

Returns the component’s associated certificate.

for k in cert.keys() {
    // It's not only an identical `Cert`, it's the same one.
    assert!(std::ptr::eq(k.cert(), &cert));
}

pub fn bundle(&self) -> &'a ComponentBundle<Key<P, R>>

Returns this amalgamation’s bundle.

pub fn component(&self) -> &'a Key<P, R>

Returns this amalgamation’s component.

Examples

// Display some information about any unknown components.
for k in cert.keys() {
    eprintln!(" - {:?}", k.component());
}

pub fn key(&self) -> &'a Key<P, R>

Returns the KeyAmalgamation’s key.

pub fn self_signatures( &self, ) -> impl Iterator<Item = &'a Signature> + Send + Sync

Returns the component’s self-signatures.

The signatures are validated, and they are sorted by their creation time, most recent first.

Examples

for (i, ka) in cert.keys().enumerate() {
    eprintln!("Key #{} ({}) has {:?} self signatures",
              i, ka.key().fingerprint(),
              ka.self_signatures().count());
}

pub fn certifications( &self, ) -> impl Iterator<Item = &'a Signature> + Send + Sync

Returns the component’s third-party certifications.

The signatures are not validated. They are sorted by their creation time, most recent first.

Examples

for k in cert.keys() {
    eprintln!("Key {} has {:?} unverified, third-party certifications",
              k.key().fingerprint(),
              k.certifications().count());
}

pub fn self_revocations( &self, ) -> impl Iterator<Item = &'a Signature> + Send + Sync

Returns the component’s revocations that were issued by the certificate holder.

The revocations are validated, and they are sorted by their creation time, most recent first.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for k in cert.keys() {
    eprintln!("Key {} has {:?} revocation certificates.",
              k.key().fingerprint(),
              k.self_revocations().count());
}

pub fn other_revocations( &self, ) -> impl Iterator<Item = &'a Signature> + Send + Sync

Returns the component’s revocations that were issued by other certificates.

The revocations are not validated. They are sorted by their creation time, most recent first.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for k in cert.keys() {
    eprintln!("Key {} has {:?} unverified, third-party revocation certificates.",
              k.key().fingerprint(),
              k.other_revocations().count());
}

pub fn signatures(&self) -> impl Iterator<Item = &'a Signature> + Send + Sync

Returns all of the component’s signatures.

Only the self-signatures are validated. The signatures are sorted first by type, then by creation time. The self revocations come first, then the self signatures, then any certification approval key signatures, certifications, and third-party revocations coming last. This function may return additional types of signatures that could be associated to this component.

Examples

use openpgp::policy::StandardPolicy;
let p = &StandardPolicy::new();

for (i, ka) in cert.keys().enumerate() {
    eprintln!("Key #{} ({}) has {:?} signatures",
              i, ka.key().fingerprint(),
              ka.signatures().count());
}

impl<'a, P, R, R2> KeyAmalgamation<'a, P, R, R2>

where Self: PrimaryKey<'a, P, R>, P: 'a + KeyParts, R: 'a + KeyRole,

pub fn valid_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK, ) -> impl Iterator<Item = &Signature> + Send + Sync

where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

Returns the third-party certifications issued by the specified key, and valid at the specified time.

This function returns the certifications issued by the specified key. Specifically, it returns a certification if:

• it is well-formed,
• it is live with respect to the reference time,
• it conforms to the policy, and
• the signature is cryptographically valid.

This method is implemented on a KeyAmalgamation and not a ValidKeyAmalgamation, because a third-party certification does not require the key to be self-signed.

Examples

Alice has certified that a certificate belongs to Bob on two occasions. Whereas KeyAmalgamation::valid_certifications_by_key returns both certifications, KeyAmalgamation::active_certifications_by_key only returns the most recent certification.

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;

const P: &StandardPolicy = &StandardPolicy::new();

let alice: Cert = // ...
let bob: Cert = // ...

let bob_pk = bob.primary_key();

let valid_certifications = bob_pk.valid_certifications_by_key(
    P, None, alice.primary_key().key());
// Alice certified Bob's certificate twice.
assert_eq!(valid_certifications.count(), 2);

let active_certifications = bob_pk.active_certifications_by_key(
    P, None, alice.primary_key().key());
// But only the most recent one is active.
assert_eq!(active_certifications.count(), 1);

pub fn active_certifications_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK, ) -> impl Iterator<Item = &Signature> + Send + Sync

where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

Returns any active third-party certifications issued by the specified key.

This function is like KeyAmalgamation::valid_certifications_by_key, but it only returns active certifications. Active certifications are the most recent valid certifications with respect to the reference time.

Although there is normally only a single active certification, there can be multiple certifications with the same timestamp. In this case, all of them are returned.

Unlike self-signatures, multiple third-party certifications issued by the same key at the same time can be sensible. For instance, Alice may fully trust a CA for user IDs in a particular domain, and partially trust it for everything else. This can only be expressed using multiple certifications.

This method is implemented on a KeyAmalgamation and not a ValidKeyAmalgamation, because a third-party certification does not require the user ID to be self-signed.

Examples

See the examples for KeyAmalgamation::valid_certifications_by_key.

pub fn valid_third_party_revocations_by_key<T, PK>( &self, policy: &'a dyn Policy, reference_time: T, issuer: PK, ) -> impl Iterator<Item = &Signature> + Send + Sync

where T: Into<Option<SystemTime>>, PK: Into<&'a Key<PublicParts, UnspecifiedRole>>,

Returns the third-party revocations issued by the specified key, and valid at the specified time.

This function returns the revocations issued by the specified key. Specifically, it returns a revocation if:

• it is well-formed,
• it is a hard revocation, or it is live with respect to the reference time,
• it conforms to the policy, and
• the signature is cryptographically valid.

This method is implemented on a KeyAmalgamation and not a ValidKeyAmalgamation, because a third-party revocation does not require the key to be self-signed.

Examples

Alice revoked Bob’s certificate.

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;

const P: &StandardPolicy = &StandardPolicy::new();

let alice: Cert = // ...
let bob: Cert = // ...

let ka = bob.primary_key();

let revs = ka.valid_third_party_revocations_by_key(
    P, None, alice.primary_key().key());
// Alice revoked Bob's certificate.
assert_eq!(revs.count(), 1);

Trait Implementations

impl<'a, P, R, R2> Clone for KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts, R: 'a + KeyRole, R2: Copy,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, P, R, R2: Debug> Debug for KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts + Debug, R: 'a + KeyRole + Debug,

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

Formats the value using the given formatter.

impl<'a> From<&'a KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a PrimaryKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a SubordinateKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a ErasedKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: &'a PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: &'a SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: &'a ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: &'a PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: &'a SubordinateKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: &'a ErasedKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut PrimaryKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut SubordinateKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut ErasedKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: &'a mut ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut SubordinateKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: &'a mut ErasedKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a, P: 'a + KeyParts> From<KeyAmalgamation<'a, P, PrimaryRole, ()>> for ErasedKeyAmalgamation<'a, P>

fn from(ka: PrimaryKeyAmalgamation<'a, P>) -> Self

Converts to this type from the input type.

impl<'a, P: 'a + KeyParts> From<KeyAmalgamation<'a, P, SubordinateRole, ()>> for ErasedKeyAmalgamation<'a, P>

fn from(ka: SubordinateKeyAmalgamation<'a, P>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: PrimaryKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(ka: PrimaryKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: SubordinateKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(ka: SubordinateKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: ErasedKeyAmalgamation<'a, PublicParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(ka: PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, PrimaryRole, ()>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(ka: PrimaryKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(ka: SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, SubordinateRole, ()>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(ka: SubordinateKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, SecretParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, UnspecifiedParts>

fn from(p: ErasedKeyAmalgamation<'a, SecretParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, PublicParts>

fn from(p: PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(ka: PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, PublicParts>

fn from(p: SubordinateKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(ka: SubordinateKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a> From<KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, PublicParts>

fn from(p: ErasedKeyAmalgamation<'a, UnspecifiedParts>) -> Self

Converts to this type from the input type.

impl<'a, P, R, R2> From<ValidKeyAmalgamation<'a, P, R, R2>> for KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts, R: 'a + KeyRole, R2: Copy,

fn from(vka: ValidKeyAmalgamation<'a, P, R, R2>) -> Self

Converts to this type from the input type.

impl<'a, P, R, R2: PartialEq> PartialEq for KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts + PartialEq, R: 'a + KeyRole + PartialEq,

fn eq(&self, other: &KeyAmalgamation<'a, P, R, R2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a PrimaryKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a SubordinateKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a ErasedKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for &'a PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for &'a SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( p: &'a SubordinateKeyAmalgamation<'a, UnspecifiedParts>, ) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for &'a ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a ErasedKeyAmalgamation<'a, UnspecifiedParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a mut PrimaryKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( p: &'a mut SubordinateKeyAmalgamation<'a, PublicParts>, ) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: &'a mut ErasedKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for &'a mut PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( p: &'a mut PrimaryKeyAmalgamation<'a, UnspecifiedParts>, ) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for &'a mut SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( p: &'a mut SubordinateKeyAmalgamation<'a, UnspecifiedParts>, ) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<&'a mut KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for &'a mut ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( p: &'a mut ErasedKeyAmalgamation<'a, UnspecifiedParts>, ) -> Result<Self>

Performs the conversion.

impl<'a, P, P2> TryFrom<KeyAmalgamation<'a, P, UnspecifiedRole, bool>> for PrimaryKeyAmalgamation<'a, P2>

where P: 'a + KeyParts, P2: 'a + KeyParts,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(ka: ErasedKeyAmalgamation<'a, P>) -> Result<Self>

Performs the conversion.

impl<'a, P, P2> TryFrom<KeyAmalgamation<'a, P, UnspecifiedRole, bool>> for SubordinateKeyAmalgamation<'a, P2>

where P: 'a + KeyParts, P2: 'a + KeyParts,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(ka: ErasedKeyAmalgamation<'a, P>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, PublicParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: PrimaryKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, PublicParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: SubordinateKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, PublicParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: ErasedKeyAmalgamation<'a, PublicParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, UnspecifiedParts, PrimaryRole, ()>> for PrimaryKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: PrimaryKeyAmalgamation<'a, UnspecifiedParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, UnspecifiedParts, SubordinateRole, ()>> for SubordinateKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: SubordinateKeyAmalgamation<'a, UnspecifiedParts>) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<KeyAmalgamation<'a, UnspecifiedParts, UnspecifiedRole, bool>> for ErasedKeyAmalgamation<'a, SecretParts>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(p: ErasedKeyAmalgamation<'a, UnspecifiedParts>) -> Result<Self>

Performs the conversion.

impl<'a, P, R, R2> StructuralPartialEq for KeyAmalgamation<'a, P, R, R2>

where P: 'a + KeyParts, R: 'a + KeyRole,