replace try with ?

src/core.rs

@@ -33,7 +33,7 @@ pub trait I2CDevice {
     /// the previous SMBus command.
     fn smbus_read_byte(&mut self) -> Result<u8, Self::Error> {
         let mut buf = [0_u8];
-        try!(self.read(&mut buf));
+        self.read(&mut buf)?;
         Ok(buf[0])
     }
 
@@ -49,7 +49,7 @@ pub trait I2CDevice {
     ///
     /// The register is specified through the Comm byte.
     fn smbus_read_byte_data(&mut self, register: u8) -> Result<u8, Self::Error> {
-        try!(self.smbus_write_byte(register));
+        self.smbus_write_byte(register)?;
         self.smbus_read_byte()
     }
 
@@ -63,8 +63,8 @@ pub trait I2CDevice {
     /// Read 2 bytes from a given register on a device (lsb first)
     fn smbus_read_word_data(&mut self, register: u8) -> Result<u16, Self::Error> {
         let mut buf: [u8; 2] = [0x00; 2];
-        try!(self.smbus_write_byte(register));
-        try!(self.read(&mut buf));
+        self.smbus_write_byte(register)?;
+        self.read(&mut buf)?;
         Ok(LittleEndian::read_u16(&buf))
     }
 
@@ -78,8 +78,8 @@ pub trait I2CDevice {
     /// 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) -> Result<u16, Self::Error> {
         let mut buf: [u8; 2] = [0x00; 2];
-        try!(self.smbus_write_word_data(register, value));
-        try!(self.read(&mut buf));
+        self.smbus_write_word_data(register, value)?;
+        self.read(&mut buf)?;
         Ok(LittleEndian::read_u16(&buf))
     }
 

src/ffi.rs

@@ -9,12 +9,12 @@
 #![allow(dead_code)]
 #![allow(non_camel_case_types)]
 
+use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
 use nix;
-use std::mem;
-use std::ptr;
 use std::io::Cursor;
+use std::mem;
 use std::os::unix::prelude::*;
-use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
+use std::ptr;
 
 pub type I2CError = nix::Error;
 
@@ -175,12 +175,12 @@ ioctl!(bad ioctl_set_i2c_slave_address with I2C_SLAVE);
 ioctl!(bad ioctl_i2c_smbus with I2C_SMBUS);
 
 pub fn i2c_set_slave_address(fd: RawFd, slave_address: u16) -> Result<(), nix::Error> {
-    try!(unsafe {
+    unsafe {
         // NOTE: the generated ioctl call expected as pointer to a u8 but
         // we just want to provide the u8 directly, so we just cast to a pointer.
         // This is correct behavior.
         ioctl_set_i2c_slave_address(fd, slave_address as *mut u8)
-    });
+    }?;
     Ok(())
 }
 
@@ -220,13 +220,13 @@ pub fn i2c_smbus_write_quick(fd: RawFd, bit: bool) -> Result<(), I2CError> {
 #[inline]
 pub fn i2c_smbus_read_byte(fd: RawFd) -> Result<u8, I2CError> {
     let mut data = i2c_smbus_data::empty();
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_READ,
                          0,
                          I2CSMBusSize::I2C_SMBUS_BYTE,
                          &mut data)
-    });
+    }?;
     Ok(data.block[0])
 }
 
@@ -244,44 +244,44 @@ pub fn i2c_smbus_write_byte(fd: RawFd, value: u8) -> Result<(), I2CError> {
 #[inline]
 pub fn i2c_smbus_read_byte_data(fd: RawFd, register: u8) -> Result<u8, I2CError> {
     let mut data = i2c_smbus_data::empty();
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_READ,
                          register,
                          I2CSMBusSize::I2C_SMBUS_BYTE_DATA,
                          &mut data)
-    });
+    }?;
     Ok(data.block[0])
 }
 
 #[inline]
 pub fn i2c_smbus_write_byte_data(fd: RawFd, register: u8, value: u8) -> Result<(), I2CError> {
     let mut data = i2c_smbus_data::empty();
     data.block[0] = value;
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_WRITE,
                          register,
                          I2CSMBusSize::I2C_SMBUS_BYTE_DATA,
                          &mut data)
-    });
+    }?;
     Ok(())
 }
 
 #[inline]
 pub fn i2c_smbus_read_word_data(fd: RawFd, register: u8) -> Result<u16, I2CError> {
     let mut data = i2c_smbus_data::empty();
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_READ,
                          register,
                          I2CSMBusSize::I2C_SMBUS_WORD_DATA,
                          &mut data)
-    });
+    }?;
 
     Ok(Cursor::new(&data.block[..])
-           .read_u16::<NativeEndian>()
-           .unwrap())
+        .read_u16::<NativeEndian>()
+        .unwrap())
 }
 
 
@@ -292,13 +292,13 @@ pub fn i2c_smbus_write_word_data(fd: RawFd, register: u8, value: u16) -> Result<
         .write_u16::<NativeEndian>(value)
         .unwrap();
 
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_WRITE,
                          register,
                          I2CSMBusSize::I2C_SMBUS_WORD_DATA,
                          &mut data)
-    });
+    }?;
     Ok(())
 }
 
@@ -309,45 +309,48 @@ pub fn i2c_smbus_process_call(fd: RawFd, register: u8, value: u16) -> Result<u16
         .write_u16::<NativeEndian>(value)
         .unwrap();
 
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_WRITE,
                          register,
                          I2CSMBusSize::I2C_SMBUS_PROC_CALL,
                          &mut data)
-    });
+    }?;
     Ok(Cursor::new(&data.block[..])
-           .read_u16::<NativeEndian>()
-           .unwrap())
+        .read_u16::<NativeEndian>()
+        .unwrap())
 }
 
 #[inline]
 pub fn i2c_smbus_read_block_data(fd: RawFd, register: u8) -> Result<Vec<u8>, I2CError> {
     let mut data = i2c_smbus_data::empty();
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_READ,
                          register,
                          I2CSMBusSize::I2C_SMBUS_BLOCK_DATA,
                          &mut data)
-    });
+    }?;
 
     // create a vector from the data in the block starting at byte
     // 1 and ending after count bytes after that
     let count = data.block[0];
     Ok((&data.block[1..(count + 1) as usize]).to_vec())
 }
 
-pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, register: u8, len: u8) -> Result<Vec<u8>, I2CError> {
+pub fn i2c_smbus_read_i2c_block_data(fd: RawFd,
+                                     register: u8,
+                                     len: u8)
+                                     -> Result<Vec<u8>, I2CError> {
     let mut data = i2c_smbus_data::empty();
     data.block[0] = len;
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_READ,
                          register,
                          I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA,
                          &mut data)
-    });
+    }?;
 
     // create a vector from the data in the block starting at byte
     // 1 and ending after count bytes after that
@@ -358,22 +361,18 @@ pub fn i2c_smbus_read_i2c_block_data(fd: RawFd, register: u8, len: u8) -> Result
 #[inline]
 pub fn i2c_smbus_write_block_data(fd: RawFd, register: u8, values: &[u8]) -> Result<(), I2CError> {
     let mut data = i2c_smbus_data::empty();
-    let len: usize = if values.len() > 32 {
-        32
-    } else {
-        values.len()
-    };
+    let len: usize = if values.len() > 32 { 32 } else { values.len() };
     data.block[0] = len as u8;
     for i in 1..(len + 1) {
         data.block[i] = values[i - 1];
     }
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_WRITE,
                          register,
                          I2CSMBusSize::I2C_SMBUS_BLOCK_DATA,
                          &mut data)
-    });
+    }?;
     Ok(())
 }
 
@@ -383,21 +382,17 @@ pub fn i2c_smbus_write_i2c_block_data(fd: RawFd,
                                       values: &[u8])
                                       -> Result<(), I2CError> {
     let mut data = i2c_smbus_data::empty();
-    let len: usize = if values.len() > 32 {
-        32
-    } else {
-        values.len()
-    };
+    let len: usize = if values.len() > 32 { 32 } else { values.len() };
     data.block[0] = len as u8;
     for i in 1..(len + 1) {
         data.block[i] = values[i - 1];
     }
-    try!(unsafe {
+    unsafe {
         i2c_smbus_access(fd,
                          I2CSMBusReadWrite::I2C_SMBUS_WRITE,
                          register,
                          I2CSMBusSize::I2C_SMBUS_I2C_BLOCK_DATA,
                          &mut data)
-    });
+    }?;
     Ok(())
 }

src/linux.rs

@@ -6,17 +6,17 @@
 // option.  This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ffi;
 use core::I2CDevice;
+use ffi;
+use nix;
 use std::error::Error;
-use std::path::Path;
-use std::fs::File;
 use std::fmt;
-use nix;
-use std::io;
+use std::fs::File;
 use std::fs::OpenOptions;
+use std::io;
 use std::io::prelude::*;
 use std::os::unix::prelude::*;
+use std::path::Path;
 
 pub struct LinuxI2CDevice {
     devfile: File,
@@ -93,15 +93,14 @@ impl LinuxI2CDevice {
     pub fn new<P: AsRef<Path>>(path: P,
                                slave_address: u16)
                                -> Result<LinuxI2CDevice, LinuxI2CError> {
-        let file = try!(OpenOptions::new()
-                            .read(true)
-                            .write(true)
-                            .open(path));
+        let file = OpenOptions::new().read(true)
+            .write(true)
+            .open(path)?;
         let mut device = LinuxI2CDevice {
             devfile: file,
             slave_address: 0, // will be set later
         };
-        try!(device.set_slave_address(slave_address));
+        device.set_slave_address(slave_address)?;
         Ok(device)
     }
 
@@ -117,7 +116,7 @@ impl LinuxI2CDevice {
     /// 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) -> Result<(), LinuxI2CError> {
-        try!(ffi::i2c_set_slave_address(self.as_raw_fd(), slave_address));
+        ffi::i2c_set_slave_address(self.as_raw_fd(), slave_address)?;
         self.slave_address = slave_address;
         Ok(())
     }
@@ -196,8 +195,12 @@ impl I2CDevice for LinuxI2CDevice {
         ffi::i2c_smbus_read_block_data(self.as_raw_fd(), register).map_err(From::from)
     }
 
-    /// Read a block of up to 32 bytes from a device via i2c_smbus_i2c_read_block_data
-    fn smbus_read_i2c_block_data(&mut self, register: u8, len: u8) -> Result<Vec<u8>, LinuxI2CError> {
+    /// Read a block of up to 32 bytes from a device via
+    /// i2c_smbus_i2c_read_block_data
+    fn smbus_read_i2c_block_data(&mut self,
+                                 register: u8,
+                                 len: u8)
+                                 -> Result<Vec<u8>, LinuxI2CError> {
         ffi::i2c_smbus_read_i2c_block_data(self.as_raw_fd(), register, len).map_err(From::from)
     }
 

src/mock.rs

@@ -5,6 +5,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option.  This file may not be copied, modified, or distributed
 // except according to those terms.
+
 use core::I2CDevice;
 use std::io;