Enum KeyUse 

#[non_exhaustive]
pub enum KeyUse {
    Signature,
    Encryption,
    Unknown(String),
}

Key use (RFC 7517 Section 4.2).

Per RFC 7517, the “use” parameter is intended to identify the intended use of the public key. While “sig” and “enc” are the defined values, the specification allows for other values via registration or collision-resistant names for private use.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Signature

Key is used for signatures.

Encryption

Key is used for encryption.

Unknown(String)

Unknown or private-use key use.

Per RFC 7517, key use values should either be registered in IANA or be a collision-resistant name. Unknown values are preserved.

Implementations

impl KeyUse

pub fn as_str(&self) -> &str

Returns the key use as a string.

Trait Implementations

impl Clone for KeyUse

fn clone(&self) -> KeyUse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyUse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyUse

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KeyUse

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

Formats the value using the given formatter.

impl From<&str> for KeyUse

fn from(s: &str) -> Self

Parses a key use string.

Per RFC 7517, unknown key use values are accepted and stored as Unknown.

impl FromStr for KeyUse

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for KeyUse

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for KeyUse

fn eq(&self, other: &KeyUse) -> 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 Serialize for KeyUse

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for KeyUse

impl StructuralPartialEq for KeyUse