pci-info 0.3.1

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

// Dead code is allowed in this module as it serves multiple platforms
#![allow(dead_code)]

use crate::{PciInfoError, PciInfoPropertyError, PciLocation};
use std::{fmt, ops::Deref};

pub(crate) struct PropertyResult<T>(Result<T, PciInfoPropertyError>);

impl<T> PropertyResult<T> {
    pub fn with_val(val: T) -> Self {
        Self(Ok(val))
    }

    pub fn with_err(err: PciInfoError) -> Self {
        Self(Err(PciInfoPropertyError::Error(Box::new(err))))
    }

    pub fn with_res(res: Result<T, PciInfoError>) -> Self {
        match res {
            Ok(v) => Self::with_val(v),
            Err(e) => Self::with_err(e),
        }
    }

    pub fn set_res_cast<U: Copy + TryInto<T> + std::fmt::Display>(
        &mut self,
        res: Result<U, PciInfoError>,
    ) {
        let v = res.and_then(|v| {
            v.try_into().map_err(|_| {
                PciInfoError::ParseError(
                    format!("Value {v} cannot fit into a {}", std::any::type_name::<T>()).into(),
                )
            })
        });

        self.set_res(v)
    }

    pub fn set_res(&mut self, res: Result<T, PciInfoError>) {
        match res {
            Ok(v) => self.set_val(v),
            Err(e) => self.set_err(e),
        }
    }

    pub fn set_val(&mut self, val: T) {
        self.0 = Ok(val);
    }

    pub fn set_err(&mut self, err: PciInfoError) {
        self.0 = Err(PciInfoPropertyError::Error(Box::new(err)));
    }

    pub fn set_empty(&mut self) {
        self.0 = Err(PciInfoPropertyError::Unsupported);
    }

    pub fn as_option(&self) -> Option<&T> {
        self.0.as_ref().ok()
    }

    pub fn as_result_ref(&self) -> Result<&T, &PciInfoPropertyError> {
        self.0.as_ref()
    }
}

impl<T> Default for PropertyResult<T> {
    fn default() -> Self {
        Self(Err(PciInfoPropertyError::Unsupported))
    }
}

impl<T: FormattablePropertyResult> fmt::Debug for PropertyResult<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.0 {
            Ok(v) => (*v).format_property(f),
            Err(PciInfoPropertyError::Unsupported) => write!(f, "n/a"),
            Err(_) => write!(f, "ERROR"),
        }
    }
}

impl<T: PartialEq> PropertyResult<T> {
    pub fn eq_val(&self, other: &T) -> bool {
        match &self.0 {
            Ok(v) => *v == *other,
            Err(_) => false,
        }
    }
}

impl<T: Copy> PropertyResult<T> {
    pub fn as_result(&self) -> Result<T, &PciInfoPropertyError> {
        self.0.as_ref().map(|v| *v)
    }
}

impl<T: Deref> PropertyResult<T> {
    pub fn as_result_deref(&self) -> Result<&T::Target, &PciInfoPropertyError> {
        self.0.as_deref()
    }
}

trait FormattablePropertyResult {
    fn format_property(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
}

impl FormattablePropertyResult for PciLocation {
    fn format_property(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl FormattablePropertyResult for u16 {
    fn format_property(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:04X}", self)
    }
}

impl FormattablePropertyResult for u8 {
    fn format_property(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:02X}", self)
    }
}

impl FormattablePropertyResult for Option<u16> {
    fn format_property(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Some(v) => write!(f, "{:04X}", v),
            None => write!(f, "none"),
        }
    }
}