diff options
Diffstat (limited to 'src/libstd/sync.rs')
| -rw-r--r-- | src/libstd/sync.rs | 60 |
1 files changed, 30 insertions, 30 deletions
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 2190475d943..d47232cc535 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -99,7 +99,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint) } #[doc(hidden)] -pub impl<Q:Owned> &self/Sem<Q> { +pub impl<Q:Owned> Sem<Q> { fn acquire(&self) { let mut waiter_nobe = None; unsafe { @@ -135,26 +135,26 @@ pub impl<Q:Owned> &self/Sem<Q> { } // FIXME(#3154) move both copies of this into Sem<Q>, and unify the 2 structs #[doc(hidden)] -pub impl &self/Sem<()> { +pub impl Sem<()> { fn access<U>(&self, blk: &fn() -> U) -> U { let mut release = None; unsafe { do task::unkillable { self.acquire(); - release = Some(SemRelease(*self)); + release = Some(SemRelease(self)); } } blk() } } #[doc(hidden)] -pub impl &self/Sem<~[Waitqueue]> { +pub impl Sem<~[Waitqueue]> { fn access<U>(&self, blk: &fn() -> U) -> U { let mut release = None; unsafe { do task::unkillable { self.acquire(); - release = Some(SemAndSignalRelease(*self)); + release = Some(SemAndSignalRelease(self)); } } blk() @@ -163,9 +163,9 @@ pub impl &self/Sem<~[Waitqueue]> { // FIXME(#3588) should go inside of access() #[doc(hidden)] -type SemRelease = SemReleaseGeneric/&self<()>; -type SemAndSignalRelease = SemReleaseGeneric/&self<~[Waitqueue]>; -struct SemReleaseGeneric<Q> { sem: &self/Sem<Q> } +type SemRelease = SemReleaseGeneric<'self, ()>; +type SemAndSignalRelease = SemReleaseGeneric<'self, ~[Waitqueue]>; +struct SemReleaseGeneric<Q> { sem: &'self Sem<Q> } impl<Q:Owned> Drop for SemReleaseGeneric/&self<Q> { fn finalize(&self) { @@ -173,13 +173,13 @@ impl<Q:Owned> Drop for SemReleaseGeneric/&self<Q> { } } -fn SemRelease(sem: &r/Sem<()>) -> SemRelease/&r { +fn SemRelease(sem: &'r Sem<()>) -> SemRelease/&r { SemReleaseGeneric { sem: sem } } -fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>) +fn SemAndSignalRelease(sem: &'r Sem<~[Waitqueue]>) -> SemAndSignalRelease/&r { SemReleaseGeneric { sem: sem @@ -187,7 +187,7 @@ fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>) } /// A mechanism for atomic-unlock-and-deschedule blocking and signalling. -pub struct Condvar { priv sem: &self/Sem<~[Waitqueue]> } +pub struct Condvar { priv sem: &'self Sem<~[Waitqueue]> } impl Drop for Condvar/&self { fn finalize(&self) {} } @@ -258,7 +258,7 @@ pub impl Condvar/&self { // mutex during unwinding. As long as the wrapper (mutex, etc) is // bounded in when it gets released, this shouldn't hang forever. struct SemAndSignalReacquire { - sem: &self/Sem<~[Waitqueue]>, + sem: &'self Sem<~[Waitqueue]>, } impl Drop for SemAndSignalReacquire/&self { @@ -272,7 +272,7 @@ pub impl Condvar/&self { } } - fn SemAndSignalReacquire(sem: &r/Sem<~[Waitqueue]>) + fn SemAndSignalReacquire(sem: &'r Sem<~[Waitqueue]>) -> SemAndSignalReacquire/&r { SemAndSignalReacquire { sem: sem @@ -610,7 +610,7 @@ pub impl RWlock { // FIXME(#3588) should go inside of read() #[doc(hidden)] struct RWlockReleaseRead { - lock: &self/RWlock, + lock: &'self RWlock, } impl Drop for RWlockReleaseRead/&self { @@ -635,7 +635,7 @@ impl Drop for RWlockReleaseRead/&self { } } -fn RWlockReleaseRead(lock: &r/RWlock) -> RWlockReleaseRead/&r { +fn RWlockReleaseRead(lock: &'r RWlock) -> RWlockReleaseRead/&r { RWlockReleaseRead { lock: lock } @@ -644,7 +644,7 @@ fn RWlockReleaseRead(lock: &r/RWlock) -> RWlockReleaseRead/&r { // FIXME(#3588) should go inside of downgrade() #[doc(hidden)] struct RWlockReleaseDowngrade { - lock: &self/RWlock, + lock: &'self RWlock, } impl Drop for RWlockReleaseDowngrade/&self { @@ -677,18 +677,18 @@ impl Drop for RWlockReleaseDowngrade/&self { } } -fn RWlockReleaseDowngrade(lock: &r/RWlock) -> RWlockReleaseDowngrade/&r { +fn RWlockReleaseDowngrade(lock: &'r RWlock) -> RWlockReleaseDowngrade/&r { RWlockReleaseDowngrade { lock: lock } } /// The "write permission" token used for rwlock.write_downgrade(). -pub struct RWlockWriteMode { priv lock: &self/RWlock } +pub struct RWlockWriteMode { priv lock: &'self RWlock } impl Drop for RWlockWriteMode/&self { fn finalize(&self) {} } /// The "read permission" token used for rwlock.write_downgrade(). -pub struct RWlockReadMode { priv lock: &self/RWlock } +pub struct RWlockReadMode { priv lock: &'self RWlock } impl Drop for RWlockReadMode/&self { fn finalize(&self) {} } pub impl RWlockWriteMode/&self { @@ -827,7 +827,7 @@ mod tests { // "load tmp = move ptr; inc tmp; store ptr <- tmp" dance. let (p,c) = comm::stream(); let m = ~Mutex(); - let m2 = ~m.clone(); + let m2 = m.clone(); let mut sharedstate = ~0; let ptr = ptr::addr_of(&(*sharedstate)); do task::spawn || { @@ -1105,13 +1105,13 @@ mod tests { // Test mutual exclusion between readers and writers. Just like the // mutex mutual exclusion test, a ways above. let (p,c) = comm::stream(); - let x2 = ~x.clone(); + let x2 = (*x).clone(); let mut sharedstate = ~0; let ptr = ptr::addr_of(&(*sharedstate)); do task::spawn || { let sharedstate: &mut int = unsafe { cast::reinterpret_cast(&ptr) }; - access_shared(sharedstate, x2, mode1, 10); + access_shared(sharedstate, &x2, mode1, 10); c.send(()); } access_shared(sharedstate, x, mode2, 10); @@ -1150,14 +1150,14 @@ mod tests { mode2: RWlockMode, make_mode2_go_first: bool) { // Much like sem_multi_resource. - let x2 = ~x.clone(); + let x2 = (*x).clone(); let (p1,c1) = comm::stream(); let (p2,c2) = comm::stream(); do task::spawn || { if !make_mode2_go_first { let _ = p2.recv(); // parent sends to us once it locks, or ... } - do lock_rwlock_in_mode(x2, mode2) { + do lock_rwlock_in_mode(&x2, mode2) { if make_mode2_go_first { c1.send(()); // ... we send to it once we lock } @@ -1207,7 +1207,7 @@ mod tests { // Child wakes up parent do x.write_cond |cond| { - let x2 = ~x.clone(); + let x2 = (*x).clone(); do task::spawn || { do x2.write_cond |cond| { let woken = cond.signal(); @@ -1218,7 +1218,7 @@ mod tests { } // Parent wakes up child let (port,chan) = comm::stream(); - let x3 = ~x.clone(); + let x3 = (*x).clone(); do task::spawn || { do x3.write_cond |cond| { chan.send(()); @@ -1253,11 +1253,11 @@ mod tests { let mut ports = ~[]; for num_waiters.times { - let xi = ~x.clone(); + let xi = (*x).clone(); let (port, chan) = comm::stream(); ports.push(port); do task::spawn || { - do lock_cond(xi, dg1) |cond| { + do lock_cond(&xi, dg1) |cond| { chan.send(()); cond.wait(); chan.send(()); @@ -1289,10 +1289,10 @@ mod tests { pub fn rwlock_kill_helper(mode1: RWlockMode, mode2: RWlockMode) { // Mutex must get automatically unlocked if failed/killed within. let x = ~RWlock(); - let x2 = ~x.clone(); + let x2 = (*x).clone(); let result: result::Result<(),()> = do task::try || { - do lock_rwlock_in_mode(x2, mode1) { + do lock_rwlock_in_mode(&x2, mode1) { fail!(); } }; |