libmedium 0.13.4

Library to interface with lm_sensors
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

use std::{
    error::Error as StdError,
    fmt::{Display, Formatter},
    io::Error as IoError,
    path::PathBuf,
};

use crate::units::Error as UnitError;

pub(crate) type Result<T> = std::result::Result<T, Error>;

/// Error returned from interacting with an hwmon.
#[derive(Debug)]
pub enum Error {
    /// The hwmon does not expose an update interval.
    UpdateIntervalNotAvailable,

    /// The hwmon does not expose the beep_enable functionality.
    BeepEnable,

    /// Error reading or writing to sysfs.
    Io {
        /// The source of the error.
        source: IoError,
        /// The path where the error occurred.
        path: PathBuf,
    },

    /// Unit conversion error.
    Unit {
        /// The source of the error.
        source: UnitError,
        /// The path where the error occurred.
        path: PathBuf,
    },

    /// You have insufficient rights.
    InsufficientRights {
        /// The path where the error occurred.
        path: PathBuf,
    },
}

impl Error {
    pub(crate) fn update_interval_not_available() -> Self {
        Self::UpdateIntervalNotAvailable
    }

    pub(crate) fn beep_enable() -> Self {
        Self::BeepEnable
    }

    pub(crate) fn io(source: IoError, path: impl Into<PathBuf>) -> Self {
        let path = path.into();

        Error::Io { source, path }
    }

    pub(crate) fn unit(source: UnitError, path: impl Into<PathBuf>) -> Self {
        let path = path.into();

        Error::Unit { source, path }
    }

    #[cfg(feature = "writeable")]
    pub(crate) fn insufficient_rights(path: impl Into<PathBuf>) -> Self {
        Self::InsufficientRights { path: path.into() }
    }
}

impl StdError for Error {
    fn cause(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            Error::UpdateIntervalNotAvailable => None,
            Error::BeepEnable => None,
            Error::Io { source, .. } => Some(source),
            Error::Unit { source, .. } => Some(source),
            Error::InsufficientRights { .. } => None,
        }
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::UpdateIntervalNotAvailable => {
                write!(f, "Hwmon does not expose an update interval")
            }
            Error::BeepEnable => {
                write!(f, "Hwmon does not expose the beep_enable functionality")
            }
            Error::Unit { source, path } => {
                write!(f, "Unit conversion error at {}: {}", path.display(), source)
            }
            Error::Io { source, path } => {
                write!(f, "Io error at {}: {}", path.display(), source)
            }
            Error::InsufficientRights { path } => {
                write!(
                    f,
                    "You have insufficient rights to write to {}",
                    path.display()
                )
            }
        }
    }
}