Struct OpenPGPKeyId

pub struct OpenPGPKeyId(String);

An OpenPGP Key ID.

The OpenPGPKeyId type wraps a String representing an OpenPGP Key ID, ensuring that it consists of exactly 16 uppercase hexadecimal characters.

Note

• This type supports constructing from both uppercase and lowercase hexadecimal characters but guarantees to return the key ID in uppercase.

• The usage of this type is highly discouraged as the keys may not be unique. This will lead to a linting error in the future.

Examples

use std::str::FromStr;

use alpm_types::{Error, OpenPGPKeyId};

// Create OpenPGPKeyId from a valid key ID
let key = OpenPGPKeyId::from_str("2F2670AC164DB36F")?;
assert_eq!(key.as_str(), "2F2670AC164DB36F");

// Attempting to create an OpenPGPKeyId from an invalid key ID will fail
assert!(OpenPGPKeyId::from_str("INVALIDKEYID").is_err());

// Format as String
assert_eq!(format!("{key}"), "2F2670AC164DB36F");

Tuple Fields

0: String

Implementations

impl OpenPGPKeyId

pub fn new(key_id: String) -> Result<Self, Error>

Creates a new OpenPGPKeyId instance.

See OpenPGPKeyId::from_str for more information on how the OpenPGP Key ID is validated.

pub fn as_str(&self) -> &str

Returns a reference to the inner OpenPGP Key ID as a &str.

pub fn into_inner(self) -> String

Consumes the OpenPGPKeyId and returns the inner String.

Trait Implementations

impl Clone for OpenPGPKeyId

fn clone(&self) -> OpenPGPKeyId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpenPGPKeyId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpenPGPKeyId

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OpenPGPKeyId

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

Converts the OpenPGPKeyId to an uppercase String.

impl From<OpenPGPKeyId> for OpenPGPIdentifier

fn from(key_id: OpenPGPKeyId) -> Self

Converts to this type from the input type.

impl FromStr for OpenPGPKeyId

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

Creates a new OpenPGPKeyId instance after validating that it follows the correct format.

A valid OpenPGP Key ID should be exactly 16 characters long and consist only of digits (0-9) and hexadecimal letters (A-F).

Errors

Returns an error if the OpenPGP Key ID is not valid.

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for OpenPGPKeyId

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

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 OpenPGPKeyId

impl StructuralPartialEq for OpenPGPKeyId