core: Error associated type bounds

Pull request: #11
Approved by: posborne

Author: AerialX

src/core.rs

@@ -7,14 +7,15 @@
 // except according to those terms.
 
 use byteorder::{ByteOrder, LittleEndian};
+use std::error::Error;
 
 /// Interface to an I2C Slave Device from an I2C Master
 ///
 /// Typical implementations will store state with references to the bus
 /// in use and the address of the slave device.  The trait is based on the
 /// Linux i2cdev interface.
 pub trait I2CDevice {
-    type Error;
+    type Error: Error;
 
     /// Read data from the device to fill the provided slice
     fn read(&mut self, data: &mut [u8]) -> Result<(), Self::Error>;

src/linux.rs

@@ -8,6 +8,7 @@
 
 use ffi;
 use core::I2CDevice;
+use std::error::Error;
 use std::path::Path;
 use std::fs::File;
 use std::fmt;
@@ -22,6 +23,7 @@ pub struct LinuxI2CDevice {
     slave_address: u16,
 }
 
+#[derive(Debug)]
 pub enum LinuxI2CError {
     Nix(nix::Error),
     Io(io::Error),
@@ -55,11 +57,27 @@ impl From<LinuxI2CError> for io::Error {
     }
 }
 
-impl fmt::Debug for LinuxI2CError {
+impl fmt::Display for LinuxI2CError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            LinuxI2CError::Nix(ref e) => fmt::Debug::fmt(e, f),
-            LinuxI2CError::Io(ref e) => fmt::Debug::fmt(e, f),
+            LinuxI2CError::Nix(ref e) => fmt::Display::fmt(e, f),
+            LinuxI2CError::Io(ref e) => fmt::Display::fmt(e, f),
+        }
+    }
+}
+
+impl Error for LinuxI2CError {
+    fn description(&self) -> &str {
+        match *self {
+            LinuxI2CError::Io(ref e) => e.description(),
+            LinuxI2CError::Nix(ref e) => e.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&Error> {
+        match *self {
+            LinuxI2CError::Io(ref e) => Some(e),
+            LinuxI2CError::Nix(ref e) => Some(e),
         }
     }
 }

src/sensors/mod.rs

@@ -6,6 +6,8 @@
 // option.  This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::error::Error;
+
 pub mod adxl345_accelerometer;
 pub mod mpl115a2_barometer;
 pub mod nunchuck;
@@ -23,15 +25,15 @@ pub struct AccelerometerSample {
 
 /// Trait for sensors that provide access to accelerometer readings (3-axis)
 pub trait Accelerometer {
-    type Error;
+    type Error: Error;
 
     /// Grab an accelerometer sample from the device
     fn accelerometer_sample(&mut self) -> Result<AccelerometerSample, Self::Error>;
 }
 
 /// Trait for sensors that provide access to temperature readings
 pub trait Thermometer {
-    type Error;
+    type Error: Error;
 
     /// Get na temperature from the sensor in degrees celsisus
     ///
@@ -42,7 +44,7 @@ pub trait Thermometer {
 
 /// Trait for sensors that provide access to pressure readings
 pub trait Barometer {
-    type Error;
+    type Error: Error;
 
     /// Get a pressure reading from the sensor in kPa
     ///

src/sensors/mpl115a2_barometer.rs

@@ -81,7 +81,7 @@ impl MPL115A2Coefficients {
     /// This should be built from a read of registers 0x04-0x0B in
     /// order.  This gets the raw, unconverted value of each
     /// coefficient.
-    pub fn new<E>(i2cdev: &mut I2CDevice<Error = E>) -> Result<MPL115A2Coefficients, E> {
+    pub fn new<E: Error>(i2cdev: &mut I2CDevice<Error=E>) -> Result<MPL115A2Coefficients, E> {
         let mut buf: [u8; 8] = [0; 8];
         try!(i2cdev.write(&[REGISTER_ADDR_A0]));
         try!(i2cdev.read(&mut buf));
@@ -97,7 +97,7 @@ impl MPL115A2Coefficients {
 
 impl MPL115A2RawReading {
     /// Create a new reading from the provided I2C Device
-    pub fn new<E>(i2cdev: &mut I2CDevice<Error = E>) -> Result<MPL115A2RawReading, E> {
+    pub fn new<E: Error>(i2cdev: &mut I2CDevice<Error=E>) -> Result<MPL115A2RawReading, E> {
         // tell the chip to do an ADC read so we can get updated values
         try!(i2cdev.smbus_write_byte_data(REGISTER_ADDR_START_CONVERSION, 0x00));
 

src/sensors/nunchuck.rs

@@ -9,7 +9,9 @@
 // Reads data from Wii Nunchuck
 
 use std::io::prelude::*;
+use std::error::Error;
 use std::thread;
+use std::fmt;
 
 use core::I2CDevice;
 
@@ -21,6 +23,31 @@ pub enum NunchuckError<E> {
     ParseError,
 }
 
+impl<E: Error> fmt::Display for NunchuckError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            NunchuckError::Error(ref e) => fmt::Display::fmt(e, f),
+            NunchuckError::ParseError => fmt::Display::fmt(self.description(), f),
+        }
+    }
+}
+
+impl<E: Error> Error for NunchuckError<E> {
+    fn description(&self) -> &str {
+        match *self {
+            NunchuckError::Error(ref e) => e.description(),
+            NunchuckError::ParseError => "Unable to Parse Data",
+        }
+    }
+
+    fn cause(&self) -> Option<&Error> {
+        match *self {
+            NunchuckError::Error(ref e) => Some(e),
+            NunchuckError::ParseError => None,
+        }
+    }
+}
+
 // TODO: Move Nunchuck code out to be an actual sensor and add tests
 
 #[derive(Debug)]