/// this call will return an error once the mutex is acquired.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn lock(&self) -> LockResult<MutexGuard<T>> {
- unsafe { self.inner.lock.lock() }
- unsafe { MutexGuard::new(&*self.inner, &self.data) }
+ unsafe {
+ self.inner.lock.lock();
+ MutexGuard::new(&*self.inner, &self.data)
+ }
}
/// Attempts to acquire this lock.
/// acquired.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> {
- if unsafe { self.inner.lock.try_lock() } {
- Ok(try!(unsafe { MutexGuard::new(&*self.inner, &self.data) }))
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.inner.lock.try_lock() {
+ Ok(try!(MutexGuard::new(&*self.inner, &self.data)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
/// Acquires this lock, see `Mutex::lock`
#[inline]
pub fn lock(&'static self) -> LockResult<MutexGuard<()>> {
- unsafe { self.lock.lock() }
- unsafe { MutexGuard::new(self, &DUMMY.0) }
+ unsafe {
+ self.lock.lock();
+ MutexGuard::new(self, &DUMMY.0)
+ }
}
/// Attempts to grab this lock, see `Mutex::try_lock`
#[inline]
pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> {
- if unsafe { self.lock.try_lock() } {
- Ok(try!(unsafe { MutexGuard::new(self, &DUMMY.0) }))
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.lock.try_lock() {
+ Ok(try!(MutexGuard::new(self, &DUMMY.0)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
/// let x = Mutex::new(vec![1, 2]);
///
/// {
- /// let y = MutexGuard::map(x.lock().unwrap(), |v| &mut v[0]);
+ /// let mut y = MutexGuard::map(x.lock().unwrap(), |v| &mut v[0]);
/// *y = 3;
/// }
///
- /// assert_eq!(&*x.lock(), &[3, 2]);
+ /// assert_eq!(&*x.lock().unwrap(), &[3, 2]);
/// ```
#[unstable(feature = "guard_map",
reason = "recently added, needs RFC for stabilization",
- issue = "0")]
+ issue = "27746")]
pub fn map<U: ?Sized, F>(this: Self, cb: F) -> MutexGuard<'mutex, U>
- where F: FnOnce(&'mutex mut T) -> &'mutex mut U {
+ where F: FnOnce(&'mutex mut T) -> &'mutex mut U
+ {
// Compute the new data while still owning the original lock
// in order to correctly poison if the callback panics.
let data = unsafe { ptr::read(&this.__data) };
// We don't want to unlock the lock by running the destructor of the
// original lock, so just read the fields we need and forget it.
- let poison = unsafe { ptr::read(&this.__poison) };
- let lock = unsafe { ptr::read(&this.__lock) };
+ let (poison, lock) = unsafe {
+ (ptr::read(&this.__poison), ptr::read(&this.__lock))
+ };
mem::forget(this);
MutexGuard {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn read(&self) -> LockResult<RwLockReadGuard<T>> {
- unsafe { self.inner.lock.read() }
- unsafe { RwLockReadGuard::new(&*self.inner, &self.data) }
+ unsafe {
+ self.inner.lock.read();
+ RwLockReadGuard::new(&*self.inner, &self.data)
+ }
}
/// Attempts to acquire this rwlock with shared read access.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn try_read(&self) -> TryLockResult<RwLockReadGuard<T>> {
- if unsafe { self.inner.lock.try_read() } {
- Ok(try!(unsafe { RwLockReadGuard::new(&*self.inner, &self.data) }))
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.inner.lock.try_read() {
+ Ok(try!(RwLockReadGuard::new(&*self.inner, &self.data)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn write(&self) -> LockResult<RwLockWriteGuard<T>> {
- unsafe { self.inner.lock.write() }
- unsafe { RwLockWriteGuard::new(&*self.inner, &self.data) }
+ unsafe {
+ self.inner.lock.write();
+ RwLockWriteGuard::new(&*self.inner, &self.data)
+ }
}
/// Attempts to lock this rwlock with exclusive write access.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<T>> {
- if unsafe { self.inner.lock.try_write() } {
- Ok(try!(unsafe { RwLockWriteGuard::new(&*self.inner, &self.data) }))
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.inner.lock.try_write() {
+ Ok(try!(RwLockWriteGuard::new(&*self.inner, &self.data)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
/// See `RwLock::read`.
#[inline]
pub fn read(&'static self) -> LockResult<RwLockReadGuard<'static, ()>> {
- unsafe { self.lock.read() }
- unsafe { RwLockReadGuard::new(self, &DUMMY.0) }
+ unsafe {
+ self.lock.read();
+ RwLockReadGuard::new(self, &DUMMY.0)
+ }
}
/// Attempts to acquire this lock with shared read access.
#[inline]
pub fn try_read(&'static self)
-> TryLockResult<RwLockReadGuard<'static, ()>> {
- if unsafe { self.lock.try_read() } {
- unsafe { Ok(try!(RwLockReadGuard::new(self, &DUMMY.0))) }
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.lock.try_read(){
+ Ok(try!(RwLockReadGuard::new(self, &DUMMY.0)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
/// See `RwLock::write`.
#[inline]
pub fn write(&'static self) -> LockResult<RwLockWriteGuard<'static, ()>> {
- unsafe { self.lock.write() }
- unsafe { RwLockWriteGuard::new(self, &DUMMY.0) }
+ unsafe {
+ self.lock.write();
+ RwLockWriteGuard::new(self, &DUMMY.0)
+ }
}
/// Attempts to lock this rwlock with exclusive write access.
#[inline]
pub fn try_write(&'static self)
-> TryLockResult<RwLockWriteGuard<'static, ()>> {
- if unsafe { self.lock.try_write() } {
- Ok(unsafe { try!(RwLockWriteGuard::new(self, &DUMMY.0)) })
- } else {
- Err(TryLockError::WouldBlock)
+ unsafe {
+ if self.lock.try_write() {
+ Ok(try!(RwLockWriteGuard::new(self, &DUMMY.0)))
+ } else {
+ Err(TryLockError::WouldBlock)
+ }
}
}
/// ```
#[unstable(feature = "guard_map",
reason = "recently added, needs RFC for stabilization",
- issue = "0")]
+ issue = "27746")]
pub fn map<U: ?Sized, F>(this: Self, cb: F) -> RwLockReadGuard<'rwlock, U>
- where F: FnOnce(&'rwlock T) -> &'rwlock U {
+ where F: FnOnce(&'rwlock T) -> &'rwlock U
+ {
let new = RwLockReadGuard {
__lock: this.__lock,
__data: cb(this.__data)
/// let x = RwLock::new(vec![1, 2]);
///
/// {
- /// let y = RwLockWriteGuard::map(x.write().unwrap(), |v| &mut v[0]);
+ /// let mut y = RwLockWriteGuard::map(x.write().unwrap(), |v| &mut v[0]);
/// assert_eq!(*y, 1);
///
/// *y = 10;
/// ```
#[unstable(feature = "guard_map",
reason = "recently added, needs RFC for stabilization",
- issue = "0")]
+ issue = "27746")]
pub fn map<U: ?Sized, F>(this: Self, cb: F) -> RwLockWriteGuard<'rwlock, U>
- where F: FnOnce(&'rwlock mut T) -> &'rwlock mut U {
+ where F: FnOnce(&'rwlock mut T) -> &'rwlock mut U
+ {
// Compute the new data while still owning the original lock
// in order to correctly poison if the callback panics.
let data = unsafe { ptr::read(&this.__data) };
// We don't want to unlock the lock by running the destructor of the
// original lock, so just read the fields we need and forget it.
- let poison = unsafe { ptr::read(&this.__poison) };
- let lock = unsafe { ptr::read(&this.__lock) };
+ let (poison, lock) = unsafe {
+ (ptr::read(&this.__poison), ptr::read(&this.__lock))
+ };
mem::forget(this);
RwLockWriteGuard {