alpm_types/
system.rs

1use serde::{Deserialize, Serialize};
2use strum::{Display, EnumString};
3
4/// CPU architecture
5///
6/// Members of the Architecture enum can be created from `&str`.
7///
8/// ## Examples
9/// ```
10/// use std::str::FromStr;
11///
12/// use alpm_types::Architecture;
13///
14/// // create Architecture from str
15/// assert_eq!(Architecture::from_str("aarch64"), Ok(Architecture::Aarch64));
16///
17/// // format as String
18/// assert_eq!("aarch64", format!("{}", Architecture::Aarch64));
19/// assert_eq!("any", format!("{}", Architecture::Any));
20/// assert_eq!("arm", format!("{}", Architecture::Arm));
21/// assert_eq!("armv6h", format!("{}", Architecture::Armv6h));
22/// assert_eq!("armv7h", format!("{}", Architecture::Armv7h));
23/// assert_eq!("i386", format!("{}", Architecture::I386));
24/// assert_eq!("i486", format!("{}", Architecture::I486));
25/// assert_eq!("i686", format!("{}", Architecture::I686));
26/// assert_eq!("pentium4", format!("{}", Architecture::Pentium4));
27/// assert_eq!("riscv32", format!("{}", Architecture::Riscv32));
28/// assert_eq!("riscv64", format!("{}", Architecture::Riscv64));
29/// assert_eq!("x86_64", format!("{}", Architecture::X86_64));
30/// assert_eq!("x86_64_v2", format!("{}", Architecture::X86_64V2));
31/// assert_eq!("x86_64_v3", format!("{}", Architecture::X86_64V3));
32/// assert_eq!("x86_64_v4", format!("{}", Architecture::X86_64V4));
33/// ```
34#[derive(
35    Clone,
36    Copy,
37    Debug,
38    Deserialize,
39    Display,
40    EnumString,
41    Eq,
42    Hash,
43    Ord,
44    PartialEq,
45    PartialOrd,
46    Serialize,
47)]
48#[non_exhaustive]
49#[strum(serialize_all = "lowercase")]
50#[serde(rename_all = "lowercase")]
51pub enum Architecture {
52    /// ARMv8 64-bit
53    Aarch64,
54    /// Any architecture
55    Any,
56    /// ARM
57    Arm,
58    /// ARMv6 hard-float
59    Armv6h,
60    /// ARMv7 hard-float
61    Armv7h,
62    /// Intel 386
63    I386,
64    /// Intel 486
65    I486,
66    /// Intel 686
67    I686,
68    /// Intel Pentium 4
69    Pentium4,
70    /// RISC-V 32-bit
71    Riscv32,
72    /// RISC-V 64-bit
73    Riscv64,
74    /// Intel x86_64
75    X86_64,
76    /// Intel x86_64 version 2
77    #[strum(to_string = "x86_64_v2")]
78    X86_64V2,
79    /// Intel x86_64 version 3
80    #[strum(to_string = "x86_64_v3")]
81    X86_64V3,
82    /// Intel x86_64 version 4
83    #[strum(to_string = "x86_64_v4")]
84    X86_64V4,
85}
86
87/// ELF architecture format.
88///
89/// This enum represents the _Class_ field in the [_ELF Header_].
90///
91/// ## Examples
92///
93/// ```
94/// use std::str::FromStr;
95///
96/// use alpm_types::ElfArchitectureFormat;
97///
98/// # fn main() -> Result<(), alpm_types::Error> {
99/// // create ElfArchitectureFormat from str
100/// assert_eq!(
101///     ElfArchitectureFormat::from_str("32"),
102///     Ok(ElfArchitectureFormat::Bit32)
103/// );
104/// assert_eq!(
105///     ElfArchitectureFormat::from_str("64"),
106///     Ok(ElfArchitectureFormat::Bit64)
107/// );
108///
109/// // format as String
110/// assert_eq!("32", format!("{}", ElfArchitectureFormat::Bit32));
111/// assert_eq!("64", format!("{}", ElfArchitectureFormat::Bit64));
112/// # Ok(())
113/// # }
114/// ```
115///
116/// [_ELF Header_]: https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#ELF_header
117#[derive(
118    Clone, Copy, Debug, Deserialize, Display, EnumString, Eq, Ord, PartialEq, PartialOrd, Serialize,
119)]
120#[non_exhaustive]
121#[strum(serialize_all = "lowercase")]
122pub enum ElfArchitectureFormat {
123    /// 32-bit
124    #[strum(to_string = "32")]
125    Bit32 = 32,
126    /// 64-bit
127    #[strum(to_string = "64")]
128    Bit64 = 64,
129}
130
131#[cfg(test)]
132mod tests {
133    use std::str::FromStr;
134
135    use rstest::rstest;
136    use strum::ParseError;
137
138    use super::*;
139
140    #[rstest]
141    #[case("aarch64", Ok(Architecture::Aarch64))]
142    #[case("any", Ok(Architecture::Any))]
143    #[case("arm", Ok(Architecture::Arm))]
144    #[case("armv6h", Ok(Architecture::Armv6h))]
145    #[case("armv7h", Ok(Architecture::Armv7h))]
146    #[case("i386", Ok(Architecture::I386))]
147    #[case("i486", Ok(Architecture::I486))]
148    #[case("i686", Ok(Architecture::I686))]
149    #[case("pentium4", Ok(Architecture::Pentium4))]
150    #[case("riscv32", Ok(Architecture::Riscv32))]
151    #[case("riscv64", Ok(Architecture::Riscv64))]
152    #[case("x86_64", Ok(Architecture::X86_64))]
153    #[case("x86_64_v2", Ok(Architecture::X86_64V2))]
154    #[case("x86_64_v3", Ok(Architecture::X86_64V3))]
155    #[case("x86_64_v4", Ok(Architecture::X86_64V4))]
156    #[case("foo", Err(ParseError::VariantNotFound))]
157    fn architecture_from_string(#[case] s: &str, #[case] arch: Result<Architecture, ParseError>) {
158        assert_eq!(Architecture::from_str(s), arch);
159    }
160
161    #[rstest]
162    #[case(Architecture::Aarch64, "aarch64")]
163    #[case(Architecture::Any, "any")]
164    #[case(Architecture::Arm, "arm")]
165    #[case(Architecture::Armv6h, "armv6h")]
166    #[case(Architecture::Armv7h, "armv7h")]
167    #[case(Architecture::I386, "i386")]
168    #[case(Architecture::I486, "i486")]
169    #[case(Architecture::I686, "i686")]
170    #[case(Architecture::Pentium4, "pentium4")]
171    #[case(Architecture::Riscv32, "riscv32")]
172    #[case(Architecture::Riscv64, "riscv64")]
173    #[case(Architecture::X86_64, "x86_64")]
174    #[case(Architecture::X86_64V2, "x86_64_v2")]
175    #[case(Architecture::X86_64V3, "x86_64_v3")]
176    #[case(Architecture::X86_64V4, "x86_64_v4")]
177    fn architecture_format_string(#[case] arch: Architecture, #[case] arch_str: &str) {
178        assert_eq!(arch_str, format!("{}", arch));
179    }
180
181    #[rstest]
182    #[case("32", Ok(ElfArchitectureFormat::Bit32))]
183    #[case("64", Ok(ElfArchitectureFormat::Bit64))]
184    #[case("foo", Err(ParseError::VariantNotFound))]
185    fn elf_architecture_format_from_string(
186        #[case] s: &str,
187        #[case] arch: Result<ElfArchitectureFormat, ParseError>,
188    ) {
189        assert_eq!(ElfArchitectureFormat::from_str(s), arch);
190    }
191
192    #[rstest]
193    #[case(ElfArchitectureFormat::Bit32, "32")]
194    #[case(ElfArchitectureFormat::Bit64, "64")]
195    fn elf_architecture_format_display(
196        #[case] arch: ElfArchitectureFormat,
197        #[case] arch_str: &str,
198    ) {
199        assert_eq!(arch_str, format!("{}", arch));
200    }
201}
alpm_types/system.rs

alpm_types/
system.rs
