core: use ? operator instead of try!

Also removes an unused import.

Author: ekmecic

examples/breathe.rs

@@ -16,27 +16,23 @@ use sysfs_pwm::{Pwm, Result};
 const BB_PWM_CHIP: u32 = 0;
 const BB_PWM_NUMBER: u32 = 0;
 
-fn pwm_increase_to_max(pwm: &Pwm,
-                       duration_ms: u32,
-                       update_period_ms: u32) -> Result<()> {
+fn pwm_increase_to_max(pwm: &Pwm, duration_ms: u32, update_period_ms: u32) -> Result<()> {
     let step: f32 = duration_ms as f32 / update_period_ms as f32;
     let mut duty_cycle = 0.0;
-    let period_ns: u32 = try!(pwm.get_period_ns());
+    let period_ns: u32 = pwm.get_period_ns()?;
     while duty_cycle < 1.0 {
-        try!(pwm.set_duty_cycle_ns((duty_cycle * period_ns as f32) as u32));
+        pwm.set_duty_cycle_ns((duty_cycle * period_ns as f32) as u32)?;
         duty_cycle += step;
     }
     pwm.set_duty_cycle_ns(period_ns)
 }
 
-fn pwm_decrease_to_minimum(pwm: &Pwm,
-                           duration_ms: u32,
-                           update_period_ms: u32) -> Result<()> {
+fn pwm_decrease_to_minimum(pwm: &Pwm, duration_ms: u32, update_period_ms: u32) -> Result<()> {
     let step: f32 = duration_ms as f32 / update_period_ms as f32;
     let mut duty_cycle = 1.0;
-    let period_ns: u32 = try!(pwm.get_period_ns());
+    let period_ns: u32 = pwm.get_period_ns()?;
     while duty_cycle > 0.0 {
-        try!(pwm.set_duty_cycle_ns((duty_cycle * period_ns as f32) as u32));
+        pwm.set_duty_cycle_ns((duty_cycle * period_ns as f32) as u32)?;
         duty_cycle -= step;
     }
     pwm.set_duty_cycle_ns(0)
@@ -47,11 +43,12 @@ fn pwm_decrease_to_minimum(pwm: &Pwm,
 fn main() {
     let pwm = Pwm::new(BB_PWM_CHIP, BB_PWM_NUMBER).unwrap(); // number depends on chip, etc.
     pwm.with_exported(|| {
-        pwm.enable(true).unwrap();
-        pwm.set_period_ns(20_000).unwrap();
-        loop {
-            pwm_increase_to_max(&pwm, 1000, 20).unwrap();
-            pwm_decrease_to_minimum(&pwm, 1000, 20).unwrap();
-        }
-    }).unwrap();
+                           pwm.enable(true).unwrap();
+                           pwm.set_period_ns(20_000).unwrap();
+                           loop {
+                               pwm_increase_to_max(&pwm, 1000, 20).unwrap();
+                               pwm_decrease_to_minimum(&pwm, 1000, 20).unwrap();
+                           }
+                       })
+        .unwrap();
 }

src/lib.rs

@@ -15,7 +15,6 @@
 //! PWM access under Linux using the PWM sysfs interface
 
 use std::io::prelude::*;
-use std::os::unix::prelude::*;
 use std::fs::File;
 use std::fs;
 use std::fs::OpenOptions;
@@ -45,25 +44,23 @@ pub type Result<T> = ::std::result::Result<T, error::Error>;
 
 /// Open the specified entry name as a writable file
 fn pwm_file_wo(chip: &PwmChip, pin: u32, name: &str) -> Result<File> {
-    let f = try!(OpenOptions::new().write(true)
-                 .open(format!("/sys/class/pwm/pwmchip{}/pwm{}/{}",
-                               chip.number,
-                               pin,
-                               name)));
+    let f = OpenOptions::new()
+        .write(true)
+        .open(format!("/sys/class/pwm/pwmchip{}/pwm{}/{}", chip.number, pin, name))?;
     Ok(f)
 }
 
 /// Open the specified entry name as a readable file
 fn pwm_file_ro(chip: &PwmChip, pin: u32, name: &str) -> Result<File> {
-    let f = try!(File::open(format!("/sys/class/pwm/pwmchip{}/pwm{}/{}", chip.number, pin, name)));
+    let f = File::open(format!("/sys/class/pwm/pwmchip{}/pwm{}/{}", chip.number, pin, name))?;
     Ok(f)
 }
 
 /// Get the u32 value from the given entry
 fn pwm_file_parse<T: FromStr>(chip: &PwmChip, pin: u32, name: &str) -> Result<T> {
     let mut s = String::with_capacity(10);
-    let mut f = try!(pwm_file_ro(chip, pin, name));
-    try!(f.read_to_string(&mut s));
+    let mut f = pwm_file_ro(chip, pin, name)?;
+    f.read_to_string(&mut s)?;
     match s.trim().parse::<T>() {
         Ok(r) => Ok(r),
         Err(_) => Err(Error::Unexpected(format!("Unexpeted value file contents: {:?}", s))),
@@ -73,15 +70,15 @@ fn pwm_file_parse<T: FromStr>(chip: &PwmChip, pin: u32, name: &str) -> Result<T>
 
 impl PwmChip {
     pub fn new(number: u32) -> Result<PwmChip> {
-        try!(fs::metadata(&format!("/sys/class/pwm/pwmchip{}", number)));
+        fs::metadata(&format!("/sys/class/pwm/pwmchip{}", number))?;
         Ok(PwmChip { number: number })
     }
 
     pub fn count(&self) -> Result<u32> {
         let npwm_path = format!("/sys/class/pwm/pwmchip{}/npwm", self.number);
-        let mut npwm_file = try!(File::open(&npwm_path));
+        let mut npwm_file = File::open(&npwm_path)?;
         let mut s = String::new();
-        try!(npwm_file.read_to_string(&mut s));
+        npwm_file.read_to_string(&mut s)?;
         match s.parse::<u32>() {
             Ok(n) => Ok(n),
             Err(_) => Err(Error::Unexpected(format!("Unexpected npwm contents: {:?}", s))),
@@ -94,7 +91,7 @@ impl PwmChip {
                                               self.number,
                                               number)) {
             let path = format!("/sys/class/pwm/pwmchip{}/export", self.number);
-            let mut export_file = try!(File::create(&path));
+            let mut export_file = File::create(&path)?;
             let _ = export_file.write_all(format!("{}", number).as_bytes());
         }
         Ok(())
@@ -105,7 +102,7 @@ impl PwmChip {
                                              self.number,
                                              number)) {
             let path = format!("/sys/class/pwm/pwmchip{}/unexport", self.number);
-            let mut export_file = try!(File::create(&path));
+            let mut export_file = File::create(&path)?;
             let _ = export_file.write_all(format!("{}", number).as_bytes());
         }
         Ok(())
@@ -117,19 +114,19 @@ impl Pwm {
     ///
     /// This function does not export the Pwm pin
     pub fn new(chip: u32, number: u32) -> Result<Pwm> {
-        let chip: PwmChip = try!(PwmChip::new(chip));
+        let chip: PwmChip = PwmChip::new(chip)?;
         Ok(Pwm {
-            chip: chip,
-            number: number,
-        })
+               chip: chip,
+               number: number,
+           })
     }
 
     /// Run a closure with the GPIO exported
     #[inline]
     pub fn with_exported<F>(&self, closure: F) -> Result<()>
         where F: FnOnce() -> Result<()>
     {
-        try!(self.export());
+        self.export()?;
         match closure() {
             Ok(()) => self.unexport(),
             Err(_) => self.unexport(),
@@ -148,13 +145,9 @@ impl Pwm {
 
     /// Enable/Disable the PWM Signal
     pub fn enable(&self, enable: bool) -> Result<()> {
-        let mut enable_file = try!(pwm_file_wo(&self.chip, self.number, "enable"));
-        let contents = if enable {
-            "1"
-        } else {
-            "0"
-        };
-        try!(enable_file.write_all(contents.as_bytes()));
+        let mut enable_file = pwm_file_wo(&self.chip, self.number, "enable")?;
+        let contents = if enable { "1" } else { "0" };
+        enable_file.write_all(contents.as_bytes())?;
         Ok(())
     }
 
@@ -168,8 +161,9 @@ impl Pwm {
     /// Value is in nanoseconds and must be less than the period.
     pub fn set_duty_cycle_ns(&self, duty_cycle_ns: u32) -> Result<()> {
         // we'll just let the kernel do the validation
-        let mut duty_cycle_file = try!(pwm_file_wo(&self.chip, self.number, "duty_cycle"));
-        try!(duty_cycle_file.write_all(format!("{}", duty_cycle_ns).as_bytes()));
+        let mut duty_cycle_file = pwm_file_wo(&self.chip, self.number, "duty_cycle")?;
+        duty_cycle_file
+            .write_all(format!("{}", duty_cycle_ns).as_bytes())?;
         Ok(())
     }
 
@@ -180,8 +174,9 @@ impl Pwm {
 
     /// The period of the PWM signal in Nanoseconds
     pub fn set_period_ns(&self, period_ns: u32) -> Result<()> {
-        let mut period_file = try!(pwm_file_wo(&self.chip, self.number, "period"));
-        try!(period_file.write_all(format!("{}", period_ns).as_bytes()));
+        let mut period_file = pwm_file_wo(&self.chip, self.number, "period")?;
+        period_file
+            .write_all(format!("{}", period_ns).as_bytes())?;
         Ok(())
     }
 }