qemu_command_builder/
common.rs

1use std::fmt::{Display, Formatter};
2use std::str::FromStr;
3
4use proptest_derive::Arbitrary;
5
6use crate::to_command::{ToArg, ToCommand};
7
8#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Arbitrary)]
9/// A QEMU boolean-like value encoded as `"yes"` or `"no"`.
10pub enum YesNo {
11    /// Emits `"yes"`.
12    Yes,
13    /// Emits `"no"`.
14    No,
15}
16
17impl Display for YesNo {
18    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
19        match self {
20            YesNo::Yes => write!(f, "yes"),
21            YesNo::No => write!(f, "no"),
22        }
23    }
24}
25impl FromStr for YesNo {
26    type Err = ();
27
28    fn from_str(s: &str) -> Result<Self, Self::Err> {
29        match s {
30            "yes" => Ok(YesNo::Yes),
31            "no" => Ok(YesNo::No),
32            _ => Err(()),
33        }
34    }
35}
36
37impl ToCommand for YesNo {
38    fn to_args(&self) -> Vec<String> {
39        let mut cmd = vec![];
40        match self {
41            YesNo::Yes => {
42                cmd.push("yes".to_string());
43            }
44            YesNo::No => {
45                cmd.push("no".to_string());
46            }
47        }
48        cmd
49    }
50}
51
52impl ToArg for YesNo {
53    fn to_arg(&self) -> &str {
54        match self {
55            YesNo::Yes => "yes",
56            YesNo::No => "no",
57        }
58    }
59}
60
61#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Arbitrary)]
62/// A QEMU boolean-like value encoded as `"on"` or `"off"`.
63pub enum OnOff {
64    /// Emits `"on"`.
65    On,
66    /// Emits `"off"`.
67    Off,
68}
69
70impl Display for OnOff {
71    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
72        match self {
73            OnOff::On => write!(f, "on"),
74            OnOff::Off => write!(f, "off"),
75        }
76    }
77}
78
79impl FromStr for OnOff {
80    type Err = ();
81
82    fn from_str(s: &str) -> Result<Self, Self::Err> {
83        match s {
84            "on" => Ok(OnOff::On),
85            "off" => Ok(OnOff::Off),
86            _ => Err(()),
87        }
88    }
89}
90
91impl ToCommand for OnOff {
92    fn to_args(&self) -> Vec<String> {
93        let mut cmd = vec![];
94        match self {
95            OnOff::On => {
96                cmd.push("on".to_string());
97            }
98            OnOff::Off => {
99                cmd.push("off".to_string());
100            }
101        }
102        cmd
103    }
104}
105
106impl ToArg for OnOff {
107    fn to_arg(&self) -> &str {
108        match self {
109            OnOff::On => "on",
110            OnOff::Off => "off",
111        }
112    }
113}
114
115#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Default, Arbitrary)]
116/// A QEMU tri-state value encoded as `"on"`, `"off"`, or `"auto"`.
117///
118/// The default is [`OnOffAuto::Auto`].
119pub enum OnOffAuto {
120    /// Emits `"on"`.
121    On,
122    /// Emits `"off"`.
123    Off,
124    /// Emits `"auto"`.
125    #[default]
126    Auto,
127}
128
129impl FromStr for OnOffAuto {
130    type Err = ();
131
132    fn from_str(s: &str) -> Result<Self, Self::Err> {
133        match s {
134            "on" => Ok(OnOffAuto::On),
135            "off" => Ok(OnOffAuto::Off),
136            "auto" => Ok(OnOffAuto::Auto),
137            _ => Err(()),
138        }
139    }
140}
141
142impl Display for OnOffAuto {
143    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
144        match self {
145            OnOffAuto::On => write!(f, "on"),
146            OnOffAuto::Off => write!(f, "off"),
147            OnOffAuto::Auto => write!(f, "auto"),
148        }
149    }
150}
151impl ToCommand for OnOffAuto {
152    fn to_args(&self) -> Vec<String> {
153        let mut cmd = vec![];
154        match self {
155            OnOffAuto::On => {
156                cmd.push("on".to_string());
157            }
158            OnOffAuto::Off => {
159                cmd.push("off".to_string());
160            }
161            OnOffAuto::Auto => {
162                cmd.push("auto".to_string());
163            }
164        }
165        cmd
166    }
167}
168
169impl ToArg for OnOffAuto {
170    fn to_arg(&self) -> &str {
171        match self {
172            OnOffAuto::On => "on",
173            OnOffAuto::Off => "off",
174            OnOffAuto::Auto => "auto",
175        }
176    }
177}
178
179#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Default, Arbitrary)]
180/// A QEMU on/off value whose Rust default is `"on"`.
181///
182/// The default is [`OnOffDefaultOn::On`].
183pub enum OnOffDefaultOn {
184    /// Emits `"on"`.
185    #[default]
186    On,
187    /// Emits `"off"`.
188    Off,
189}
190
191impl FromStr for OnOffDefaultOn {
192    type Err = ();
193
194    fn from_str(s: &str) -> Result<Self, Self::Err> {
195        match s {
196            "on" => Ok(OnOffDefaultOn::On),
197            "off" => Ok(OnOffDefaultOn::Off),
198            _ => Err(()),
199        }
200    }
201}
202
203impl Display for OnOffDefaultOn {
204    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
205        match self {
206            OnOffDefaultOn::On => write!(f, "on"),
207            OnOffDefaultOn::Off => write!(f, "off"),
208        }
209    }
210}
211impl ToCommand for OnOffDefaultOn {
212    fn to_args(&self) -> Vec<String> {
213        let mut cmd = vec![];
214        match self {
215            OnOffDefaultOn::On => {
216                cmd.push("on".to_string());
217            }
218            OnOffDefaultOn::Off => {
219                cmd.push("off".to_string());
220            }
221        }
222        cmd
223    }
224}
225
226impl ToArg for OnOffDefaultOn {
227    fn to_arg(&self) -> &str {
228        match self {
229            OnOffDefaultOn::On => "on",
230            OnOffDefaultOn::Off => "off",
231        }
232    }
233}
234
235#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Default, Arbitrary)]
236/// A QEMU on/off value whose Rust default is `"off"`.
237///
238/// The default is [`OnOffDefaultOff::Off`].
239pub enum OnOffDefaultOff {
240    /// Emits `"on"`.
241    On,
242    /// Emits `"off"`.
243    #[default]
244    Off,
245}
246
247impl Display for OnOffDefaultOff {
248    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
249        match self {
250            OnOffDefaultOff::On => write!(f, "on"),
251            OnOffDefaultOff::Off => write!(f, "off"),
252        }
253    }
254}
255
256impl FromStr for OnOffDefaultOff {
257    type Err = ();
258
259    fn from_str(s: &str) -> Result<Self, Self::Err> {
260        match s {
261            "on" => Ok(OnOffDefaultOff::On),
262            "off" => Ok(OnOffDefaultOff::Off),
263            _ => Err(()),
264        }
265    }
266}
267
268impl ToCommand for OnOffDefaultOff {
269    fn to_args(&self) -> Vec<String> {
270        let mut cmd = vec![];
271        match self {
272            OnOffDefaultOff::On => {
273                cmd.push("on".to_string());
274            }
275            OnOffDefaultOff::Off => {
276                cmd.push("off".to_string());
277            }
278        }
279        cmd
280    }
281}
282
283impl ToArg for OnOffDefaultOff {
284    fn to_arg(&self) -> &str {
285        match self {
286            OnOffDefaultOff::On => "on",
287            OnOffDefaultOff::Off => "off",
288        }
289    }
290}
291
292#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Default, Arbitrary)]
293/// Supported QEMU accelerator backends.
294///
295/// The default is [`AccelType::Tcg`].
296pub enum AccelType {
297    /// Kernel-based Virtual Machine acceleration.
298    Kvm,
299    /// Xen acceleration.
300    Xen,
301    /// Hypervisor.framework acceleration.
302    Hvf,
303    /// Amazon Nitro Enclaves acceleration.
304    Nitro,
305    /// NetBSD NVMM acceleration.
306    Nvmm,
307    /// Windows Hypervisor Platform acceleration.
308    Whpx,
309    /// Microsoft Hypervisor acceleration.
310    Mshv,
311    /// Tiny Code Generator emulation.
312    #[default]
313    Tcg,
314}
315
316impl ToArg for AccelType {
317    fn to_arg(&self) -> &str {
318        match self {
319            AccelType::Kvm => "kvm",
320            AccelType::Xen => "xen",
321            AccelType::Hvf => "hvf",
322            AccelType::Nitro => "nitro",
323            AccelType::Nvmm => "nvmm",
324            AccelType::Whpx => "whpx",
325            AccelType::Mshv => "mshv",
326            AccelType::Tcg => "tcg",
327        }
328    }
329}
330
331impl FromStr for AccelType {
332    type Err = ();
333
334    fn from_str(s: &str) -> Result<Self, Self::Err> {
335        match s {
336            "kvm" => Ok(AccelType::Kvm),
337            "xen" => Ok(AccelType::Xen),
338            "hvf" => Ok(AccelType::Hvf),
339            "nitro" => Ok(AccelType::Nitro),
340            "nvmm" => Ok(AccelType::Nvmm),
341            "whpx" => Ok(AccelType::Whpx),
342            "mshv" => Ok(AccelType::Mshv),
343            "tcg" => Ok(AccelType::Tcg),
344            _ => Err(()),
345        }
346    }
347}
348
349#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Arbitrary)]
350/// A QEMU setting encoded as `"ignore"` or `"unmap"`.
351pub enum IgnoreUnmap {
352    /// Emits `"ignore"`.
353    Ignore,
354    /// Emits `"unmap"`.
355    Unmap,
356}
357
358impl Display for IgnoreUnmap {
359    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
360        match self {
361            IgnoreUnmap::Ignore => write!(f, "ignore"),
362            IgnoreUnmap::Unmap => write!(f, "unmap"),
363        }
364    }
365}
366impl FromStr for IgnoreUnmap {
367    type Err = ();
368
369    fn from_str(s: &str) -> Result<Self, Self::Err> {
370        match s {
371            "ignore" => Ok(IgnoreUnmap::Ignore),
372            "unmap" => Ok(IgnoreUnmap::Unmap),
373            _ => Err(()),
374        }
375    }
376}
377impl ToArg for IgnoreUnmap {
378    fn to_arg(&self) -> &str {
379        match self {
380            IgnoreUnmap::Ignore => "ignore",
381            IgnoreUnmap::Unmap => "unmap",
382        }
383    }
384}
385
386#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Arbitrary)]
387/// A QEMU value encoded as `"on"`, `"off"`, or `"unmap"`.
388pub enum OnOffUnmap {
389    /// Emits `"on"`.
390    On,
391    /// Emits `"off"`.
392    Off,
393    /// Emits `"unmap"`.
394    Unmap,
395}
396
397impl Display for OnOffUnmap {
398    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
399        match self {
400            OnOffUnmap::On => write!(f, "on"),
401            OnOffUnmap::Off => write!(f, "off"),
402            OnOffUnmap::Unmap => write!(f, "unmap"),
403        }
404    }
405}
406
407impl FromStr for OnOffUnmap {
408    type Err = ();
409
410    fn from_str(s: &str) -> Result<Self, Self::Err> {
411        match s {
412            "on" => Ok(OnOffUnmap::On),
413            "off" => Ok(OnOffUnmap::Off),
414            "unmap" => Ok(OnOffUnmap::Unmap),
415            _ => Err(()),
416        }
417    }
418}
419impl ToArg for OnOffUnmap {
420    fn to_arg(&self) -> &str {
421        match self {
422            OnOffUnmap::On => "on",
423            OnOffUnmap::Off => "off",
424            OnOffUnmap::Unmap => "unmap",
425        }
426    }
427}
428
429#[derive(Debug, Clone, Hash, Ord, PartialOrd, Eq, PartialEq, Arbitrary)]
430/// A QEMU policy value encoded as `"auto"`, `"never"`, or `"always"`.
431pub enum AutoNeverAlways {
432    /// Emits `"auto"`.
433    Auto,
434    /// Emits `"never"`.
435    Never,
436    /// Emits `"always"`.
437    Always,
438}
439
440impl ToArg for AutoNeverAlways {
441    fn to_arg(&self) -> &str {
442        match self {
443            AutoNeverAlways::Auto => "auto",
444            AutoNeverAlways::Never => "never",
445            AutoNeverAlways::Always => "always",
446        }
447    }
448}
qemu_command_builder/common.rs

qemu_command_builder/
common.rs
