std: add an RAII unlocker to Mutex.

This automatically unlocks its lock when it goes out of scope, and
provides a safe(ish) method to call .wait.

1 files changed, 6 insertions, 18 deletions

diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index c2fa168a478..343eacbf429 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -11,16 +11,16 @@
 use clone::Clone;
 use kinds::Send;
 use ops::Drop;
-use option::{Option,Some,None};
+use option::Option;
 use sync::arc::UnsafeArc;
-use unstable::mutex::Mutex;
+use unstable::mutex::{Mutex, LockGuard};
 
 pub struct LittleLock {
     priv l: Mutex,
 }
 
 pub struct LittleGuard<'a> {
-    priv l: &'a mut Mutex,
+    priv l: LockGuard<'a>
 }
 
 impl Drop for LittleLock {
@@ -29,33 +29,21 @@ impl Drop for LittleLock {
     }
 }
 
-#[unsafe_destructor]
-impl<'a> Drop for LittleGuard<'a> {
-    fn drop(&mut self) {
-        unsafe { self.l.unlock(); }
-    }
-}
-
 impl LittleLock {
     pub fn new() -> LittleLock {
         unsafe { LittleLock { l: Mutex::new() } }
     }
 
     pub unsafe fn lock<'a>(&'a mut self) -> LittleGuard<'a> {
-        self.l.lock();
-        LittleGuard { l: &mut self.l }
+        LittleGuard { l: self.l.lock() }
     }
 
     pub unsafe fn try_lock<'a>(&'a mut self) -> Option<LittleGuard<'a>> {
-        if self.l.trylock() {
-            Some(LittleGuard { l: &mut self.l })
-        } else {
-            None
-        }
+        self.l.trylock().map(|guard| LittleGuard { l: guard })
     }
 
     pub unsafe fn signal(&mut self) {
-        self.l.signal();
+        self.l.signal_noguard();
     }
 }