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

// 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(&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"),
        }
    }
}