libcpuname 0.1.3

Identify CPU vendors, chips, and cores across multiple architectures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use super::Implementer;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
/// Error type indicating a failure to convert between integer-backed types.
pub struct TryFromIntError;

#[cfg(feature = "std")]
impl std::error::Error for TryFromIntError {}

impl core::fmt::Display for TryFromIntError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "out of range integral type conversion attempted")
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
/// Error type indicating a failure to find a matching CPU core name.
pub enum CoreNameError {
    /// The provided part exceeds the maximum possible value of `0xFFF`.
    InvalidPart(u16),
    /// The provided variant exceeds the maximum possible value of `0xF`.
    InvalidVariant(u8),
    /// The provided implementer has no known core names.
    NoKnownNamesForImplementer(Implementer),
    /// The provided implementer is known, but the provided part has no known core names.
    NoKnownNamesForPart(u16),
}

#[cfg(feature = "std")]
impl std::error::Error for CoreNameError {}

impl core::fmt::Display for CoreNameError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::InvalidPart(part) => write!(
                f,
                "provided part {part:X} is greater than the maximum of 0xFFF"
            ),
            Self::InvalidVariant(variant) => write!(
                f,
                "provided variant {variant:X} is greater than the maximum of 0xF"
            ),
            Self::NoKnownNamesForImplementer(implementer) => write!(
                f,
                "provided implementer {implementer} has no known core names"
            ),
            Self::NoKnownNamesForPart(part) => {
                write!(f, "provided part {part:X} has no known core names")
            }
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
/// Composite error type representing all possible errors in this module.
pub enum Error {
    /// Wrapper for [`TryFromIntError`].
    TryFromInt(TryFromIntError),
    /// Wrapper for [`CoreNameError`].
    CoreName(CoreNameError),
}

#[cfg(feature = "std")]
impl std::error::Error for Error {}

impl core::fmt::Display for Error {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::TryFromInt(e) => write!(f, "{e}"),
            Self::CoreName(e) => write!(f, "{e}"),
        }
    }
}

impl From<TryFromIntError> for Error {
    fn from(value: TryFromIntError) -> Self {
        Self::TryFromInt(value)
    }
}

impl From<CoreNameError> for Error {
    fn from(err: CoreNameError) -> Self {
        Self::CoreName(err)
    }
}

#[cfg(test)]
mod tests {
    use super::super::*;
    use super::*;

    #[test]
    fn error_conversion() {
        assert_eq!(
            Error::from(TryFromIntError),
            Error::TryFromInt(TryFromIntError)
        );
        assert_eq!(
            Error::from(CoreNameError::InvalidPart(u16::MAX)),
            Error::CoreName(CoreNameError::InvalidPart(u16::MAX))
        );
    }

    #[test]
    fn display() {
        let errors: &[Error] = &[
            TryFromIntError.into(),
            CoreNameError::InvalidPart(u16::MAX).into(),
            CoreNameError::InvalidVariant(u8::MAX).into(),
            CoreNameError::NoKnownNamesForImplementer(Implementer::Arm).into(),
            CoreNameError::NoKnownNamesForPart(u16::MAX).into(),
        ];

        assert!(errors.iter().all(|it| !it.to_string().is_empty()));
    }
}