Struct libmedium::sensors::ReadWriteTemp

pub struct ReadWriteTemp { /* fields omitted */ }

Struct that represents a read/write temp sensor.

Trait Implementations

impl Clone for ReadWriteTemp

fn clone(&self) -> ReadWriteTemp

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReadWriteTemp

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Faulty for ReadWriteTemp

fn read_faulty(&self) -> Result<bool, Error>

Reads whether this sensor is faulty or not. Returns an error, if this sensor doesn't support the feature.

impl From<ReadWriteTemp> for ReadOnlyTemp

fn from(write_temp: ReadWriteTemp) -> ReadOnlyTemp

Performs the conversion.

impl SensorBase for ReadWriteTemp

fn base(&self) -> &'static str

Returns this sensor's base like "temp" or "fan".

fn index(&self) -> u16

Returns this sensor's index.

fn hwmon_path(&self) -> &Path

Returns this sensor's hwmon's path.

fn supported_read_sub_functions(&self) -> Vec<SensorSubFunctionType>

Returns a list of all readable subfunction types supported by this sensor.

fn name(&self) -> String

If this sensor has a label, its contents are returned. Otherwise a plain sensor descriptor is returned.

fn read_raw(&self, sub_type: SensorSubFunctionType) -> Result<String, Error>

Reads this sensor's subfunction with the given type and returns its value as a raw string. You should usually prefer the specialized read functions like read_input, because they automatically convert the read value to the right type. Returns an error, if this sensor doesn't support the subtype.

fn subfunction_path(&self, sub_type: SensorSubFunctionType) -> PathBuf

Returns the path this sensor's subfunction of the given type would have.

impl TempSensor for ReadWriteTemp

fn read_type(&self) -> Result<TempType, Error>

Reads the type subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_offset(&self) -> Result<Temperature, Error>

Reads the offset subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_max_hyst(&self) -> Result<Temperature, Error>

Reads the max_hyst subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_min_hyst(&self) -> Result<Temperature, Error>

Reads the min_hyst subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_crit_hyst(&self) -> Result<Temperature, Error>

Reads the crit_hyst subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_emergency(&self) -> Result<Temperature, Error>

Reads the emergency subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_emergency_hyst(&self) -> Result<Temperature, Error>

Reads the emergency_hyst subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn read_lcrit_hyst(&self) -> Result<Temperature, Error>

Reads the lcrit_hyst subfunction of this temp sensor. Returns an error, if this sensor doesn't support the subfunction.

fn write_offset(&self, offset: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts offset and writes it to this temp's offset subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_max_hyst(&self, max_hyst: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts max_hyst and writes it to this temp's max_hyst subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_min_hyst(&self, min_hyst: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts min_hyst and writes it to this temp's min_hyst subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_crit_hyst(&self, crit_hyst: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts crit_hyst and writes it to this temp's crit_hyst subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_emergency(&self, emergency: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts emergency and writes it to this temp's emergency subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_emergency_hyst(&self, emergency_hyst: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts emergency_hyst and writes it to this temp's emergency_hyst subfunction. Returns an error, if this sensor doesn't support the subfunction.

fn write_lcrit_hyst(&self, lcrit_hyst: Temperature) -> Result<(), Error> where
    Self: WritableSensorBase, 

Converts lcrit_hyst and writes it to this temp's lcrit_hyst subfunction. Returns an error, if this sensor doesn't support the subfunction.

impl TryFrom<ReadOnlyTemp> for ReadWriteTemp

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: ReadOnlyTemp) -> Result<Self, Self::Error>

Performs the conversion.

impl WritableSensorBase for ReadWriteTemp

fn supported_write_sub_functions(&self) -> Vec<SensorSubFunctionType>

Returns a list of all writable subfunction types supported by this sensor.

fn write_raw(
    &self,
    sub_type: SensorSubFunctionType,
    raw_value: &str
) -> Result<(), Error>

Writes the given raw string value to this sensor's subfunction with the given type. You should usually prefer the specialized write functions like write_enable, because they ensure that no type mismatches occur. Returns an error, if this sensor doesn't support the subtype.

fn reset_history(&self) -> Result<(), Error>

Resets this sensor's history. Returns an error if this functionality is not supported by the sensor.

fn state(&self) -> Result<SensorState, Error>

Returns a SensorState struct that represents the state of all writable subfunctions of this sensor.

fn write_state(&self, state: &SensorState) -> Result<(), Error>

Writes the given state to this sensor. Returns an error and writes nothing if the given state contains one or more subfunctions that this sensor does not support.

fn write_state_lossy(&self, state: &SensorState) -> Result<(), Error>

Writes the given state to this sensor. All subfunction types contained in the given state that are not supported by this sensor will be ignored.