pci-info 0.1.0

A crate to enumerate PCI devices on desktop operating systems and/or parse PCI configuration headers
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::{borrow::Cow, fmt::Debug, fmt::Display};

// define an alias in case in the future we want
// to use Rc or Box for some platforms.
// Arc is best because it saves on cloning and is Send.
type HeapPtr<T> = std::sync::Arc<T>;

/// A string type used to optimize size and
/// various operations on the error types of this crate.
///
/// # Examples
/// This shows some conversions to `&str` and `String`
/// using different methods:
/// ```rust
/// # use pci_info::PciInfoErrorString;
/// let errs: PciInfoErrorString = "test".into();
///
/// // Convert to a String calling `to_string()`
/// let s: String = errs.to_string();
/// assert_eq!(s, "test");
///
/// // Convert to a String calling `into()`
/// let errs2 = errs.clone();
/// let s: String = errs2.into();
/// assert_eq!(s, "test");
///
/// // Convert to a &str calling `into()` on a `&PciInfoErrorString`
/// let s: &str = (&errs).into();
/// assert_eq!(s, "test");
///
/// // Convert to a &str calling `as_str()`
/// let s: &str = errs.as_str();
/// assert_eq!(s, "test");
///
/// // Use the `Display` trait
/// let s = format!("{errs}");
/// assert_eq!(s, "test");
///
/// // Use the `Debug` trait
/// let s = format!("{errs:?}");
/// assert_eq!(s, "\"test\"");
/// ```
#[derive(Clone)]
pub struct PciInfoErrorString(HeapPtr<Cow<'static, str>>);

impl From<PciInfoErrorString> for String {
    fn from(value: PciInfoErrorString) -> Self {
        value.to_string()
    }
}

impl<'a> From<&'a PciInfoErrorString> for &'a str {
    fn from(value: &'a PciInfoErrorString) -> Self {
        &value.0
    }
}

impl PciInfoErrorString {
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl From<&'static str> for PciInfoErrorString {
    fn from(value: &'static str) -> Self {
        Self(HeapPtr::new(value.into()))
    }
}

impl From<String> for PciInfoErrorString {
    fn from(value: String) -> Self {
        Self(HeapPtr::new(value.into()))
    }
}

impl Display for PciInfoErrorString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Debug for PciInfoErrorString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "\"{}\"", self.0)
    }
}

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

    #[test]
    fn pciinfoerrorstring_staticstr() {
        let errs: PciInfoErrorString = "test".into();

        let s: String = errs.to_string();
        assert_eq!(s, "test");

        let errs2 = errs.clone();
        let s: String = errs2.into();
        assert_eq!(s, "test");

        let s: &str = (&errs).into();
        assert_eq!(s, "test");

        let s: &str = errs.as_str();
        assert_eq!(s, "test");

        let s = format!("{errs}");
        assert_eq!(s, "test");

        let s = format!("{errs:?}");
        assert_eq!(s, "\"test\"");
    }

    #[test]
    fn pciinfoerrorstring_string() {
        let errs: PciInfoErrorString = format!("test").into();

        let s: String = errs.to_string();
        assert_eq!(s, "test");

        let errs2 = errs.clone();
        let s: String = errs2.into();
        assert_eq!(s, "test");

        let s: &str = (&errs).into();
        assert_eq!(s, "test");

        let s: &str = errs.as_str();
        assert_eq!(s, "test");

        let s = format!("{errs}");
        assert_eq!(s, "test");

        let s = format!("{errs:?}");
        assert_eq!(s, "\"test\"");
    }
}