fn clone(&self) -> () { () }
}
+impl<T:Clone> Clone for ~T {
+ #[inline(always)]
+ fn clone(&self) -> ~T { ~(**self).clone() }
+}
+
macro_rules! clone_impl(
($t:ty) => {
impl Clone for $t {
use at_vec;
use cast;
use char;
+use clone::Clone;
use cmp::{Equiv, TotalOrd, Ordering, Less, Equal, Greater};
use libc;
use option::{None, Option, Some};
}
}
+impl Clone for ~str {
+ #[inline(always)]
+ fn clone(&self) -> ~str {
+ self.to_str() // hilarious
+ }
+}
+
#[cfg(test)]
mod tests {
use char;
match value {
None => {
let value = create();
- clone_value = Some(value.clone());
+ clone_value = Some((*value).clone());
Some(value)
}
Some(value) => {
- clone_value = Some(value.clone());
+ clone_value = Some((*value).clone());
Some(value)
}
}
// Successfully installed the global pointer
// Take a handle to return
- let clone = state.clone();
+ let clone = (*state).clone();
// Install a runtime exit function to destroy the global object
do at_exit {
use container::{Container, Mutable};
use cast;
use cmp::{Eq, Equiv, Ord, TotalOrd, Ordering, Less, Equal, Greater};
+use clone::Clone;
use iter::BaseIter;
use iter;
use kinds::Copy;
}
}
+impl<A:Clone> Clone for ~[A] {
+ #[inline]
+ fn clone(&self) -> ~[A] {
+ let mut dolly = ~[];
+ vec::reserve(&mut dolly, self.len());
+ for self.each |item| {
+ dolly.push(item.clone());
+ }
+ return dolly;
+ }
+}
+
// ___________________________________________________________________________
#[cfg(test)]
#[test] #[should_fail] #[ignore(cfg(windows))]
pub fn test_rw_arc_poison_wr() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.write |one| {
fail_unless!(*one == 2);
#[test] #[should_fail] #[ignore(cfg(windows))]
pub fn test_rw_arc_poison_ww() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.write |one| {
fail_unless!(*one == 2);
#[test] #[should_fail] #[ignore(cfg(windows))]
pub fn test_rw_arc_poison_dw() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.write_downgrade |write_mode| {
do (&write_mode).write |one| {
#[test] #[ignore(cfg(windows))]
pub fn test_rw_arc_no_poison_rr() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.read |one| {
fail_unless!(*one == 2);
#[test] #[ignore(cfg(windows))]
pub fn test_rw_arc_no_poison_rw() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.read |one| {
fail_unless!(*one == 2);
#[test] #[ignore(cfg(windows))]
pub fn test_rw_arc_no_poison_dr() {
let arc = ~RWARC(1);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
do task::try || {
do arc2.write_downgrade |write_mode| {
let read_mode = arc2.downgrade(write_mode);
#[test]
pub fn test_rw_arc() {
let arc = ~RWARC(0);
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
let (p,c) = comm::stream();
do task::spawn || {
// Readers try to catch the writer in the act
let mut children = ~[];
for 5.times {
- let arc3 = ~arc.clone();
+ let arc3 = (*arc).clone();
do task::task().future_result(|+r| children.push(r)).spawn
|| {
do arc3.read |num| {
for 10.times {
let ((rp1,rc1),(rp2,rc2)) = (comm::stream(),comm::stream());
reader_convos.push((rc1, rp2));
- let arcn = ~arc.clone();
+ let arcn = (*arc).clone();
do task::spawn || {
rp1.recv(); // wait for downgrader to give go-ahead
do arcn.read |state| {
}
// Writer task
- let arc2 = ~arc.clone();
+ let arc2 = (*arc).clone();
let ((wp1,wc1),(wp2,wc2)) = (comm::stream(),comm::stream());
do task::spawn || {
wp1.recv();
// "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 || {
// 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);
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
}
// 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();
}
// 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(());
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(());
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!();
}
};
debug!("colive iteration %?", i);
let mut new_colive = ~[];
for colive.eachi |i, this_colive| {
- let mut result = ~this_colive.clone();
+ let mut result = this_colive.clone();
let this = proto.get_state_by_id(i);
for this_colive.ones |j| {
let next = proto.get_state_by_id(j);