linux: remove I2CResult to appease newer rustc

Pull request: #11
Approved by: posborne

Author: AerialX

src/linux.rs

@@ -82,8 +82,6 @@ impl Error for LinuxI2CError {
     }
 }
 
-type I2CResult<T> = Result<T, LinuxI2CError>;
-
 impl AsRawFd for LinuxI2CDevice {
     fn as_raw_fd(&self) -> RawFd {
         self.devfile.as_raw_fd()
@@ -118,7 +116,7 @@ impl LinuxI2CDevice {
     /// (it is done internally).  Calling this method is only
     /// necessary if you need to change the slave device and you do
     /// not want to create a new device.
-    fn set_slave_address(&mut self, slave_address: u16) -> I2CResult<()> {
+    fn set_slave_address(&mut self, slave_address: u16) -> Result<(), LinuxI2CError> {
         try!(ffi::i2c_set_slave_address(self.as_raw_fd(), slave_address));
         self.slave_address = slave_address;
         Ok(())
@@ -129,17 +127,17 @@ impl I2CDevice for LinuxI2CDevice {
     type Error = LinuxI2CError;
 
     /// Read data from the device to fill the provided slice
-    fn read(&mut self, data: &mut [u8]) -> I2CResult<()> {
+    fn read(&mut self, data: &mut [u8]) -> Result<(), LinuxI2CError> {
         self.devfile.read(data).map_err(From::from).map(drop)
     }
 
     /// Write the provided buffer to the device
-    fn write(&mut self, data: &[u8]) -> I2CResult<()> {
+    fn write(&mut self, data: &[u8]) -> Result<(), LinuxI2CError> {
         self.devfile.write(data).map_err(From::from).map(drop)
     }
 
     /// This sends a single bit to the device, at the place of the Rd/Wr bit
-    fn smbus_write_quick(&mut self, bit: bool) -> I2CResult<()> {
+    fn smbus_write_quick(&mut self, bit: bool) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_quick(self.as_raw_fd(), bit).map_err(From::from)
     }
 
@@ -148,44 +146,44 @@ impl I2CDevice for LinuxI2CDevice {
     /// Some devices are so simple that this interface is enough; for
     /// others, it is a shorthand if you want to read the same register as in
     /// the previous SMBus command.
-    fn smbus_read_byte(&mut self) -> I2CResult<u8> {
+    fn smbus_read_byte(&mut self) -> Result<u8, LinuxI2CError> {
         ffi::i2c_smbus_read_byte(self.as_raw_fd()).map_err(From::from)
     }
 
     /// Write a single byte to a sdevice, without specifying a device register
     ///
     /// This is the opposite operation as smbus_read_byte.  As with read_byte,
     /// no register is specified.
-    fn smbus_write_byte(&mut self, value: u8) -> I2CResult<()> {
+    fn smbus_write_byte(&mut self, value: u8) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_byte(self.as_raw_fd(), value).map_err(From::from)
     }
 
     /// Read a single byte from a device, from a designated register
     ///
     /// The register is specified through the Comm byte.
-    fn smbus_read_byte_data(&mut self, register: u8) -> I2CResult<u8> {
+    fn smbus_read_byte_data(&mut self, register: u8) -> Result<u8, LinuxI2CError> {
         ffi::i2c_smbus_read_byte_data(self.as_raw_fd(), register).map_err(From::from)
     }
 
     /// Write a single byte to a specific register on a device
     ///
     /// The register is specified through the Comm byte.
-    fn smbus_write_byte_data(&mut self, register: u8, value: u8) -> I2CResult<()> {
+    fn smbus_write_byte_data(&mut self, register: u8, value: u8) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_byte_data(self.as_raw_fd(), register, value).map_err(From::from)
     }
 
     /// Read 2 bytes form a given register on a device
-    fn smbus_read_word_data(&mut self, register: u8) -> I2CResult<u16> {
+    fn smbus_read_word_data(&mut self, register: u8) -> Result<u16, LinuxI2CError> {
         ffi::i2c_smbus_read_word_data(self.as_raw_fd(), register).map_err(From::from)
     }
 
     /// Write 2 bytes to a given register on a device
-    fn smbus_write_word_data(&mut self, register: u8, value: u16) -> I2CResult<()> {
+    fn smbus_write_word_data(&mut self, register: u8, value: u16) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_word_data(self.as_raw_fd(), register, value).map_err(From::from)
     }
 
     /// Select a register, send 16 bits of data to it, and read 16 bits of data
-    fn smbus_process_word(&mut self, register: u8, value: u16) -> I2CResult<u16> {
+    fn smbus_process_word(&mut self, register: u8, value: u16) -> Result<u16, LinuxI2CError> {
         ffi::i2c_smbus_process_call(self.as_raw_fd(), register, value).map_err(From::from)
     }
 
@@ -194,7 +192,7 @@ impl I2CDevice for LinuxI2CDevice {
     /// The actual number of bytes available to read is returned in the count
     /// byte.  This code returns a correctly sized vector containing the
     /// count bytes read from the device.
-    fn smbus_read_block_data(&mut self, register: u8) -> I2CResult<Vec<u8>> {
+    fn smbus_read_block_data(&mut self, register: u8) -> Result<Vec<u8>, LinuxI2CError> {
         ffi::i2c_smbus_read_block_data(self.as_raw_fd(), register).map_err(From::from)
     }
 
@@ -203,13 +201,13 @@ impl I2CDevice for LinuxI2CDevice {
     /// The opposite of the Block Read command, this writes up to 32 bytes to
     /// a device, to a designated register that is specified through the
     /// Comm byte. The amount of data is specified in the Count byte.
-    fn smbus_write_block_data(&mut self, register: u8, values: &[u8]) -> I2CResult<()> {
+    fn smbus_write_block_data(&mut self, register: u8, values: &[u8]) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_block_data(self.as_raw_fd(), register, values).map_err(From::from)
     }
 
     /// Select a register, send 1 to 31 bytes of data to it, and reads
     /// 1 to 31 bytes of data from it.
-    fn smbus_process_block(&mut self, register: u8, values: &[u8]) -> I2CResult<()> {
+    fn smbus_process_block(&mut self, register: u8, values: &[u8]) -> Result<(), LinuxI2CError> {
         ffi::i2c_smbus_write_i2c_block_data(self.as_raw_fd(), register, values).map_err(From::from)
     }
 }