Add more capability functionality and improve API

src/attribute.rs

@@ -63,7 +63,7 @@ pub trait SysAttributeExt: SysAttribute + Eq {
     /// read and parse the attribute value
     fn parse<T: FromStr<Err=E>, E>(&self, entity: &dyn crate::SysEntity) -> Result<T, EitherErr2<std::io::Error, E>> {
         let s = self.read_str(entity).map_err(EitherErr2::First)?;
-        T::from_str(&s).map_err(EitherErr2::Second)
+        T::from_str(s.trim_end_matches('\n')).map_err(EitherErr2::Second)
     }
 }
 

src/capability.rs

@@ -19,6 +19,12 @@ pub fn attributes<'a, A: crate::SysAttribute + Eq + 'a, R: std::borrow::Borrow<A
     )
 }
 
+/// Build a Capabilities implementor which needs specific functions to evaluate to true for some attribute
+pub fn complex<'a, A: crate::SysAttribute + 'a, R: std::borrow::Borrow<A> + 'a, F: (FnMut(&R) -> bool) + 'a>(requirements: impl Iterator<Item=F>) -> impl Capabilities<A, R> + 'a {
+    AllNeedsCapabilities::new(
+        requirements.collect()
+    )
+}
 
 struct AllNeedsCapabilities<'a, 'f, A: crate::SysAttribute + 'a, R: std::borrow::Borrow<A> + 'a, F: (FnMut(&R) -> bool) + 'f> {
     wanted: Vec<F>,
@@ -51,3 +57,32 @@ impl <'a, 'f, A: crate::SysAttribute + 'a, R: std::borrow::Borrow<A> + 'a, F: (F
         wants.into_iter().all(|item| item)
     }
 }
+
+/// Chain two capabilities requirements together such that the new capabilities are only satisfied when both inner capabilities are satisfied
+pub fn and<A: crate::SysAttribute,  R: std::borrow::Borrow<A>>(first: impl Capabilities<A, R>, second: impl Capabilities<A, R>) -> impl Capabilities<A, R>  {
+    ChainCapabilities::new(first, second)
+}
+
+struct ChainCapabilities<A: crate::SysAttribute,  R: std::borrow::Borrow<A>, X: Capabilities<A, R>, Y: Capabilities<A, R>> {
+    first: X,
+    second: Y,
+    _attr_ty: std::marker::PhantomData<A>,
+    _attr_brw_ty: std::marker::PhantomData<R>,
+}
+
+impl <A: crate::SysAttribute,  R: std::borrow::Borrow<A>, X: Capabilities<A, R>, Y: Capabilities<A, R>> ChainCapabilities<A, R, X, Y> {
+    pub(crate) fn new(first: X, second: Y) -> Self {
+        Self {
+            first,
+            second,
+            _attr_ty: Default::default(),
+            _attr_brw_ty: Default::default(),
+        }
+    }
+}
+
+impl <A: crate::SysAttribute,  R: std::borrow::Borrow<A>, X: Capabilities<A, R>, Y: Capabilities<A, R>> Capabilities<A, R> for ChainCapabilities<A, R, X, Y> {
+    fn can(&mut self, capabilities: &Vec<R>) -> bool {
+        self.first.can(capabilities) && self.second.can(capabilities)
+    }
+}

src/entity.rs

@@ -72,9 +72,21 @@ impl <X: SysEntity> SysEntityRawExt for X {
 pub trait SysEntityAttributes<A: crate::SysAttribute + Eq>: SysEntity + Sized {
     /// Get attributes available on this entity;
     fn capabilities(&self) -> Vec<A>;
+
+    /// 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)
+    }
 }
 
+/// sysfs class entity attribute type extension
 pub trait SysEntityAttributesExt<A: crate::SysAttribute + Eq>: SysEntityAttributes<A> {
+    /// Returns true if self is capable of the provided capabilities
     fn capable<C: crate::capability::Capabilities<A, A>>(&self, mut capabilities: C) -> bool {
         capabilities.can(&self.capabilities())
     }
@@ -83,6 +95,11 @@ pub trait SysEntityAttributesExt<A: crate::SysAttribute + Eq>: SysEntityAttribut
     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())
+    }
 }
 
 impl <A: crate::SysAttribute + Eq, X: SysEntityAttributes<A>> SysEntityAttributesExt<A> for X {}

src/hwmon.rs

@@ -96,6 +96,8 @@ pub enum HwMonAttributeItem {
     Min,
     /// Maximum
     Max,
+    /// Readable name for another attribute
+    Label,
 }
 
 impl HwMonAttributeItem {
@@ -104,6 +106,7 @@ impl HwMonAttributeItem {
             Self::Input => "input",
             Self::Min => "min",
             Self::Max => "max",
+            Self::Label => "label"
         }
     }
     
@@ -213,7 +216,7 @@ impl HwMonPath {
     }
     
     /// Get a hwmon attribute (file contents)
-    pub fn attribute(&self, attr: HwMonAttribute) -> IoResult<String> {
+    fn attribute(&self, attr: HwMonAttribute) -> IoResult<String> {
         self.attribute_str(&attr.to_attr_str())
     }
     

src/lib.rs

@@ -13,7 +13,7 @@ pub use basic::BasicEntityPath;
 pub mod capability;
 
 mod entity;
-pub use entity::{EntityPath, SysEntity, SysEntityRawExt, SysEntityAttributes};
+pub use entity::{EntityPath, SysEntity, SysEntityRawExt, SysEntityAttributes, SysEntityAttributesExt};
 
 mod errors;
 pub use errors::{EitherErr2, ValueEnumError};