format: replace try! with ? operator

Signed-off-by: Paul Osborne <osbpau@gmail.com>

Author: posborne

src/config.rs

@@ -171,24 +171,24 @@ impl GpioConfig {
 
         // check /etc/gpio.toml
         if fs::metadata("/etc/gpio.toml").is_ok() {
-            config_instances.push(try!(Self::from_file("/etc/gpio.toml")));
+            config_instances.push(Self::from_file("/etc/gpio.toml")?);
         }
         // /etc/gpio.d/*.toml
         for fragment in glob("/etc/gpio.d/*.toml").unwrap().filter_map(Result::ok) {
-            config_instances.push(try!(Self::from_file(fragment)));
+            config_instances.push(Self::from_file(fragment)?);
         }
 
         // additional from command-line
         for fragment in configs {
-            config_instances.push(try!(Self::from_file(fragment)));
+            config_instances.push(Self::from_file(fragment)?);
         }
 
         if config_instances.is_empty() {
             Err(Error::NoConfigFound)
         } else {
             let mut cfg = config_instances.remove(0);
             for higher_priority_cfg in config_instances {
-                try!(cfg.update(higher_priority_cfg));
+                cfg.update(higher_priority_cfg)?;
             }
             Ok(cfg)
         }
@@ -197,10 +197,11 @@ impl GpioConfig {
     /// Load a GPIO config from the specified path
     pub fn from_file<P: AsRef<Path>>(path: P) -> Result<GpioConfig, Error> {
         let mut contents = String::new();
-        let mut f = try!(File::open(path));
-        try!(f.read_to_string(&mut contents));
-        let config = try!(GpioConfig::from_str(&contents[..]));
-        try!(config.validate());
+        let mut f = File::open(path)?;
+        f.read_to_string(&mut contents)?;
+        let config = GpioConfig::from_str(&contents[..])?;
+        config.validate()?;
+
         Ok(config)
     }
 

src/export.rs

@@ -39,11 +39,11 @@ pub fn unexport(pin_config: &PinConfig, symlink_root: Option<&str>) -> Result<()
         for name in &pin_config.names {
             let mut dst = path::PathBuf::from(symroot);
             dst.push(name);
-            try!(match fs::remove_file(dst) {
-                Ok(_) => Ok(()),
-                Err(ref e) if e.kind() == ErrorKind::NotFound => Ok(()),
-                Err(e) => Err(e),
-            });
+            match fs::remove_file(dst) {
+                Ok(_) => (),
+                Err(ref e) if e.kind() == ErrorKind::NotFound => (),
+                Err(e) => return Err(e.into()),
+            };
         }
     }
 
@@ -123,35 +123,27 @@ pub fn export(pin_config: &PinConfig, symlink_root: Option<&str>) -> Result<()>
     // if there is a symlink root provided, create symlink
     if let Some(symroot) = symlink_root {
         // create root directory if not exists
-        try!(fs::create_dir_all(symroot));
+        fs::create_dir_all(symroot)?;
 
         // set the pin direction
-        try!(
-            pin_config
-                .get_pin()
-                .set_direction(pin_config.direction.clone())
-        );
+        pin_config
+            .get_pin()
+            .set_direction(pin_config.direction.clone())?;
 
-        // set active low direction
-        try!(
-            pin_config
-                .get_pin()
-                .set_active_low(pin_config.active_low.clone())
-        );
+        // set active low directio
+        pin_config
+            .get_pin()
+            .set_active_low(pin_config.active_low.clone())?;
 
         // create symlink for each name
         for name in &pin_config.names {
             let mut dst = path::PathBuf::from(symroot);
             dst.push(name);
-            try!(
-                match unix_fs::symlink(format!("/sys/class/gpio/gpio{}", pin_config.num), dst) {
-                    Ok(_) => Ok(()),
-                    Err(e) => match e.kind() {
-                        ErrorKind::AlreadyExists => Ok(()),
-                        _ => Err(e),
-                    },
-                }
-            );
+            match unix_fs::symlink(format!("/sys/class/gpio/gpio{}", pin_config.num), dst) {
+                Err(ref e) if e.kind() == ErrorKind::AlreadyExists => (),
+                Err(e) => return Err(e.into()),
+                _ => (),
+            };
         }
     }