sysfuss 0.3.0

sysfs wrapper for convenience
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
140
141
142
143
144
145
146
147
148
149
150

use std::path::Path;
use std::convert::AsRef;
use std::io::Result as IoResult;

use crate::EitherErr2;
use crate::SysAttributeExt;

/// sysfs class entity functionality
#[cfg(feature = "derive")]
pub trait SysEntity: AsRef<Path> + core::fmt::Debug {
    /// Convert specialized entity into general entity path container
    fn to_entity_path(self) -> EntityPath;
    
    /// Get the entity's name
    fn name(&self) -> IoResult<String>;

    /// Try to get the entity's root sysfs dir (probably `/`)
    fn root(&self) -> Option<crate::SysPath> {
        crate::SysPath::from_entity_path(self)
    }
}

/// sysfs class entity functionality
#[cfg(not(feature = "derive"))]
pub trait SysEntity: AsRef<Path> {
    /// Convert specialized entity into general entity path container
    fn to_entity_path(self) -> EntityPath;

    /// Get the entity's name
    fn name(&self) -> IoResult<String>;

    /// Try to get the entity's root sysfs dir (probably `/`)
    fn root(&self) -> Option<crate::SysPath> {
        crate::SysPath::from_entity_path(self)
    }
}

/// sysfs class entity functionality extension
pub trait SysEntityRawExt: SysEntity {
    /// Get an attribute on the entity
    fn attribute<A: crate::SysAttribute, T: std::str::FromStr<Err=E>, E>(&self, attr: A) -> Result<T, EitherErr2<std::io::Error, E>>;
    /// Get an attribute by filename in the entity's directory
    fn attribute_str<A: AsRef<Path>>(&self, attr: A) -> IoResult<String>;
    
    /// Returns true when the entity has the attribute
    fn exists<A: crate::SysAttribute>(&self, attr: A) -> bool;
    
    /// Returns true when the entity has the attribute
    fn exists_str<A: AsRef<Path>>(&self, attr: A) -> bool;
}

impl <X: SysEntity> SysEntityRawExt for X {
    fn attribute<A: crate::SysAttribute, T: std::str::FromStr<Err=E>, E>(&self, attr: A) -> Result<T, EitherErr2<std::io::Error, E>> {
        attr.parse(self)
    }
    
    fn attribute_str<A: AsRef<Path>>(&self, attr: A) -> IoResult<String> {
        std::fs::read_to_string(self.as_ref().join(attr))
    }
    
    fn exists_str<A: AsRef<Path>>(&self, attr: A) -> bool {
        self.as_ref().join(attr).exists()
    }
    
    fn exists<A: crate::SysAttribute>(&self, attr: A) -> bool {
        attr.exists(self)
    }
}


/// sysfs class entity attribute type indicator
pub trait SysEntityAttributes<A: crate::SysAttribute>: SysEntity {
    /// Get attributes available on this entity;
    fn capabilities(&self) -> Vec<A>;
}

/// sysfs class entity attribute type extension
pub trait SysEntityAttributesExt<A: crate::SysAttribute>: SysEntityAttributes<A> + Sized {
    /// Returns true if self is capable of the provided capabilities
    fn capable<C: crate::capability::Capabilities<A, Self>>(&self, mut capabilities: C) -> bool {
        capabilities.satisfies(self)
    }

    /// Get an attribute on the entity
    fn attribute<T: std::str::FromStr<Err=E>, E>(&self, attr: A) -> Result<T, EitherErr2<std::io::Error, E>> {
        attr.parse(self)
    }

    /// Set an attribute on the entity
    fn set<V: std::string::ToString>(&self, attr: A, value: V) -> IoResult<()> {
        attr.write_str(self, &value.to_string())
    }

    /// Read entity attribute value
    fn read_value(&self, attr: &A) -> IoResult<Vec<u8>> {
        attr.read_value(self)
    }

    /// Write entity attribute value
    fn write_value(&self, attr: &A, value: &[u8]) -> IoResult<()> {
        attr.write_value(self, value)
    }

    /// Returns true when the entity has the attribute
    fn exists(&self, attr: &A) -> bool {
        attr.exists(self)
    }
}

impl <A: crate::SysAttribute, X: SysEntityAttributes<A>> SysEntityAttributesExt<A> for X {}

/// sysfs class entity implementors
#[cfg_attr(feature = "derive", derive(Debug, Clone))]
pub enum EntityPath {
    /// hwmon
    HwMon(crate::HwMonPath),
    /// power_supply
    PowerSupply(crate::PowerSupplyPath),
    /// Generic
    Generic(crate::BasicEntityPath),
    /// Miscellaneous
    Custom(std::sync::Arc<Box<dyn SysEntity>>),
}

impl EntityPath {
    fn inner(&self) -> &'_ dyn SysEntity {
        match self {
            Self::HwMon(inner) => inner,
            Self::PowerSupply(inner) => inner,
            Self::Generic(inner) => inner,
            Self::Custom(inner) => inner.as_ref().as_ref(),
        }
    }
}

impl AsRef<Path> for EntityPath {
    fn as_ref(&self) -> &Path {
        self.inner().as_ref()
    }
}

impl SysEntity for EntityPath {
    fn to_entity_path(self) -> Self {
        self
    }
    
    fn name(&self) -> IoResult<String> {
        self.inner().name()
    }
}