1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
18 pub struct Flag { failed: UnsafeCell<bool> }
19 pub const FLAG_INIT: Flag = Flag { failed: UnsafeCell { value: false } };
23 pub fn borrow(&self) -> LockResult<Guard> {
24 let ret = Guard { panicking: Thread::panicking() };
25 if unsafe { *self.failed.get() } {
26 Err(new_poison_error(ret))
33 pub fn done(&self, guard: &Guard) {
34 if !guard.panicking && Thread::panicking() {
35 unsafe { *self.failed.get() = true; }
40 pub fn get(&self) -> bool {
41 unsafe { *self.failed.get() }
45 #[allow(missing_copy_implementations)]
50 /// A type of error which can be returned whenever a lock is acquired.
52 /// Both Mutexes and RwLocks are poisoned whenever a task fails while the lock
53 /// is held. The precise semantics for when a lock is poisoned is documented on
54 /// each lock, but once a lock is poisoned then all future acquisitions will
55 /// return this error.
57 pub struct PoisonError<T> {
61 /// An enumeration of possible errors which can occur while calling the
62 /// `try_lock` method.
64 pub enum TryLockError<T> {
65 /// The lock could not be acquired because another task failed while holding
68 Poisoned(PoisonError<T>),
69 /// The lock could not be acquired at this time because the operation would
75 /// A type alias for the result of a lock method which can be poisoned.
77 /// The `Ok` variant of this result indicates that the primitive was not
78 /// poisoned, and the `Guard` is contained within. The `Err` variant indicates
79 /// that the primitive was poisoned. Note that the `Err` variant *also* carries
80 /// the associated guard, and it can be acquired through the `into_inner`
83 pub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>;
85 /// A type alias for the result of a nonblocking locking method.
87 /// For more information, see `LockResult`. A `TryLockResult` doesn't
88 /// necessarily hold the associated guard in the `Err` type as the lock may not
89 /// have been acquired for other reasons.
91 pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;
93 impl<T> fmt::Show for PoisonError<T> {
94 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
95 "poisoned lock: another task failed inside".fmt(f)
99 impl<T> PoisonError<T> {
100 /// Consumes this error indicating that a lock is poisoned, returning the
101 /// underlying guard to allow access regardless.
103 pub fn into_guard(self) -> T { self.guard }
106 impl<T> FromError<PoisonError<T>> for TryLockError<T> {
107 fn from_error(err: PoisonError<T>) -> TryLockError<T> {
108 TryLockError::Poisoned(err)
112 impl<T> fmt::Show for TryLockError<T> {
113 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
115 TryLockError::Poisoned(ref p) => p.fmt(f),
116 TryLockError::WouldBlock => {
117 "try_lock failed because the operation would block".fmt(f)
123 pub fn new_poison_error<T>(guard: T) -> PoisonError<T> {
124 PoisonError { guard: guard }
127 pub fn map_result<T, U, F>(result: LockResult<T>, f: F)
129 where F: FnOnce(T) -> U {
132 Err(PoisonError { guard }) => Err(new_poison_error(f(guard)))