use cast::transmute_mut;
use prelude::*;
+use util::replace;
/*
A dynamic, mutable location.
fail!(~"attempt to take an empty cell");
}
- let mut value = None;
- value <-> self.value;
- value.unwrap()
+ replace(&mut self.value, None).unwrap()
}
/// Returns the value, failing if the cell is full.
use unstable;
use vec;
use unstable::Exclusive;
+use util::replace;
use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
#[inline(always)]
fn send(&self, x: T) {
unsafe {
- let mut endp = None;
let mut self_endp = transmute_mut(&self.endp);
- endp <-> *self_endp;
+ let endp = replace(self_endp, None);
*self_endp = Some(streamp::client::data(endp.unwrap(), x))
}
}
#[inline(always)]
fn try_send(&self, x: T) -> bool {
unsafe {
- let mut endp = None;
let mut self_endp = transmute_mut(&self.endp);
- endp <-> *self_endp;
+ let endp = replace(self_endp, None);
match streamp::client::try_data(endp.unwrap(), x) {
Some(next) => {
*self_endp = Some(next);
#[inline(always)]
fn recv(&self) -> T {
unsafe {
- let mut endp = None;
let mut self_endp = transmute_mut(&self.endp);
- endp <-> *self_endp;
+ let endp = replace(self_endp, None);
let streamp::data(x, endp) = recv(endp.unwrap());
*self_endp = Some(endp);
x
#[inline(always)]
fn try_recv(&self) -> Option<T> {
unsafe {
- let mut endp = None;
let mut self_endp = transmute_mut(&self.endp);
- endp <-> *self_endp;
+ let endp = replace(self_endp, None);
match try_recv(endp.unwrap()) {
Some(streamp::data(x, endp)) => {
*self_endp = Some(endp);
#[inline(always)]
fn peek(&self) -> bool {
unsafe {
- let mut endp = None;
let mut self_endp = transmute_mut(&self.endp);
- endp <-> *self_endp;
+ let mut endp = replace(self_endp, None);
let peek = match endp {
Some(ref mut endp) => peek(endp),
None => fail!(~"peeking empty stream")
};
- *self_endp <-> endp;
+ *self_endp = endp;
peek
}
}
let mut result = None;
// we have to swap the ports array so we aren't borrowing
// aliasable mutable memory.
- let mut ports = ~[];
- ports <-> *self_ports;
+ let mut ports = replace(self_ports, ~[]);
while result.is_none() && ports.len() > 0 {
let i = wait_many(ports);
match ports[i].try_recv() {
}
}
}
- ports <-> *self_ports;
+ *self_ports = ports;
result
}
}
fn send(&self, x: T) {
let mut xx = Some(x);
do self.ch.with_imm |chan| {
- let mut x = None;
- x <-> xx;
+ let x = replace(&mut xx, None);
chan.send(x.unwrap())
}
}
fn try_send(&self, x: T) -> bool {
let mut xx = Some(x);
do self.ch.with_imm |chan| {
- let mut x = None;
- x <-> xx;
+ let x = replace(&mut xx, None);
chan.try_send(x.unwrap())
}
}
/// Expands the capacity of the array and re-insert each of the
/// existing buckets.
fn resize(&mut self, new_capacity: uint) {
- let old_capacity = self.buckets.len();
self.resize_at = resize_at(new_capacity);
- let mut old_buckets = vec::from_fn(new_capacity, |_| None);
- self.buckets <-> old_buckets;
+ let old_buckets = replace(&mut self.buckets,
+ vec::from_fn(new_capacity, |_| None));
self.size = 0;
- for uint::range(0, old_capacity) |i| {
- let mut bucket = None;
- bucket <-> old_buckets[i];
+ do vec::consume(old_buckets) |_, bucket| {
self.insert_opt_bucket(bucket);
}
}
};
let len_buckets = self.buckets.len();
- let mut bucket = None;
- self.buckets[idx] <-> bucket;
+ let bucket = replace(&mut self.buckets[idx], None);
let value = match bucket {
None => None,
- Some(bucket) => {
- let Bucket{value: value, _} = bucket;
+ Some(Bucket{value, _}) => {
Some(value)
},
};
let size = self.size - 1;
idx = self.next_bucket(idx, len_buckets);
while self.buckets[idx].is_some() {
- let mut bucket = None;
- bucket <-> self.buckets[idx];
+ let bucket = replace(&mut self.buckets[idx], None);
self.insert_opt_bucket(bucket);
idx = self.next_bucket(idx, len_buckets);
}
}
fn consume(&mut self, f: &fn(K, V)) {
- let mut buckets = ~[];
- self.buckets <-> buckets;
+ let buckets = replace(&mut self.buckets, ~[]);
self.size = 0;
do vec::consume(buckets) |_, bucket| {
match bucket {
None => {},
- Some(bucket) => {
- let Bucket{key: key, value: value, _} = bucket;
+ Some(Bucket{key, value, _}) => {
f(key, value)
}
}
use ptr;
use task;
use vec;
+use util::replace;
static SPIN_COUNT: uint = 0;
// optimistic path
match p.header.state {
Full => {
- let mut payload = None;
- payload <-> p.payload;
+ let payload = replace(&mut p.payload, None);
p.header.state = Empty;
return Some(payload.unwrap())
},
fail!(~"blocking on already blocked packet")
},
Full => {
- let mut payload = None;
- payload <-> p.payload;
+ let payload = replace(&mut p.payload, None);
let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
if !old_task.is_null() {
unsafe {
unsafe {
let this: &mut SendPacketBuffered<T,Tbuffer> = transmute(self);
if this.p != None {
- let mut p = None;
- p <-> this.p;
+ let p = replace(&mut this.p, None);
sender_terminate(p.unwrap())
}
}
pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
fn unwrap(&mut self) -> *mut Packet<T> {
- let mut p = None;
- p <-> self.p;
- p.unwrap()
+ replace(&mut self.p, None).unwrap()
}
fn header(&mut self) -> *mut PacketHeader {
fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
//error!("send reuse_buffer");
- let mut tmp = None;
- tmp <-> self.buffer;
- tmp.unwrap()
+ replace(&mut self.buffer, None).unwrap()
}
}
unsafe {
let this: &mut RecvPacketBuffered<T,Tbuffer> = transmute(self);
if this.p != None {
- let mut p = None;
- p <-> this.p;
+ let p = replace(&mut this.p, None);
receiver_terminate(p.unwrap())
}
}
pub impl<T:Owned,Tbuffer:Owned> RecvPacketBuffered<T, Tbuffer> {
fn unwrap(&mut self) -> *mut Packet<T> {
- let mut p = None;
- p <-> self.p;
- p.unwrap()
+ replace(&mut self.p, None).unwrap()
}
fn reuse_buffer(&mut self) -> BufferResource<Tbuffer> {
- let mut tmp = None;
- tmp <-> self.buffer;
- tmp.unwrap()
+ replace(&mut self.buffer, None).unwrap()
}
}
#[inline(always)]
pub fn with<T,R>(
ptr: @mut T,
- mut value: T,
+ value: T,
op: &fn() -> R) -> R
{
- value <-> *ptr;
+ let prev = replace(ptr, value);
let result = op();
- *ptr = value;
+ *ptr = prev;
return result;
}
use uint;
use unstable::intrinsics;
use vec;
+use util;
#[cfg(not(test))] use cmp::Equiv;
let next_ln = v.len() - 1;
// Save the last element. We're going to overwrite its position
- let mut work_elt = v.pop();
+ let work_elt = v.pop();
// We still should have room to work where what last element was
assert!(capacity(v) >= ln);
// Pretend like we have the original length so we can use
// Swap out the element we want from the end
let vp = raw::to_mut_ptr(*v);
let vp = ptr::mut_offset(vp, next_ln - 1);
- *vp <-> work_elt;
- work_elt
+ util::replace_ptr(vp, work_elt)
}
}
/// Prepend an element to the vector
pub fn unshift<T>(v: &mut ~[T], x: T) {
- let mut vv = ~[x];
- *v <-> vv;
+ let vv = util::replace(v, ~[x]);
v.push_all_move(vv);
}
v.push(x);
let mut j = len;
while j > i {
- v[j] <-> v[j - 1];
+ swap(*v, j, j - 1);
j -= 1;
}
}
let mut j = i;
while j < len - 1 {
- v[j] <-> v[j + 1];
+ swap(*v, j, j + 1);
j += 1;
}
v.pop()
// holes we create in the vector. That ensures that, if the
// iterator fails then we won't try to clean up the consumed
// elements during unwinding
- let mut x = intrinsics::init();
+ let x = intrinsics::init();
let p = ptr::mut_offset(p, i);
- x <-> *p;
- f(i, x);
+ f(i, util::replace_ptr(p, x));
}
}
// holes we create in the vector. That ensures that, if the
// iterator fails then we won't try to clean up the consumed
// elements during unwinding
- let mut x = intrinsics::init();
+ let x = intrinsics::init();
let p = ptr::mut_offset(p, i);
- x <-> *p;
- f(i, x);
+ f(i, util::replace_ptr(p, x));
}
}
}
let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
unsafe {
- let mut val = intrinsics::uninit();
- val <-> *valptr;
+ let val = util::replace_ptr(valptr, intrinsics::uninit());
raw::set_len(v, ln - 1u);
val
}
}
let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]);
unsafe {
- let mut val = intrinsics::init();
- val <-> *valptr;
+ let val = util::replace_ptr(valptr, intrinsics::init());
raw::set_len(v, ln - 1u);
val
}
fail!(fmt!("vec::swap_remove - index %u >= length %u", index, ln));
}
if index < ln - 1 {
- v[index] <-> v[ln - 1];
+ swap(*v, index, ln - 1);
}
v.pop()
}
unsafe {
do as_mut_buf(rhs) |p, len| {
for uint::range(0, len) |i| {
- let mut x = intrinsics::uninit();
- x <-> *ptr::mut_offset(p, i);
+ let x = util::replace_ptr(ptr::mut_offset(p, i),
+ intrinsics::uninit());
push(&mut *v, x);
}
}
unsafe {
do as_mut_buf(rhs) |p, len| {
for uint::range(0, len) |i| {
- let mut x = intrinsics::init();
- x <-> *ptr::mut_offset(p, i);
+ let x = util::replace_ptr(ptr::mut_offset(p, i),
+ intrinsics::init());
push(&mut *v, x);
}
}
unsafe {
// This loop is optimized out for non-drop types.
for uint::range(newlen, oldlen) |i| {
- let mut dropped = intrinsics::uninit();
- dropped <-> *ptr::mut_offset(p, i);
+ util::replace_ptr(ptr::mut_offset(p, i), intrinsics::uninit());
}
}
}
unsafe {
// This loop is optimized out for non-drop types.
for uint::range(newlen, oldlen) |i| {
- let mut dropped = intrinsics::init();
- dropped <-> *ptr::mut_offset(p, i);
+ util::replace_ptr(ptr::mut_offset(p, i), intrinsics::init());
}
}
}
// last_written < next_to_read < ln
if *ptr::mut_offset(p, next_to_read) ==
*ptr::mut_offset(p, last_written) {
- let mut dropped = intrinsics::uninit();
- dropped <-> *ptr::mut_offset(p, next_to_read);
+ util::replace_ptr(ptr::mut_offset(p, next_to_read),
+ intrinsics::uninit());
} else {
last_written += 1;
// last_written <= next_to_read < ln
if next_to_read != last_written {
- *ptr::mut_offset(p, last_written) <->
- *ptr::mut_offset(p, next_to_read);
+ util::swap_ptr(ptr::mut_offset(p, last_written),
+ ptr::mut_offset(p, next_to_read));
}
}
// last_written <= next_to_read < ln
// last_written < next_to_read < ln
if *ptr::mut_offset(p, next_to_read) ==
*ptr::mut_offset(p, last_written) {
- let mut dropped = intrinsics::init();
- dropped <-> *ptr::mut_offset(p, next_to_read);
+ util::replace_ptr(ptr::mut_offset(p, next_to_read),
+ intrinsics::init());
} else {
last_written += 1;
// last_written <= next_to_read < ln
if next_to_read != last_written {
- *ptr::mut_offset(p, last_written) <->
- *ptr::mut_offset(p, next_to_read);
+ util::swap_ptr(ptr::mut_offset(p, last_written),
+ ptr::mut_offset(p, next_to_read));
}
}
// last_written <= next_to_read < ln
if !f(&v[i]) {
deleted += 1;
} else if deleted > 0 {
- v[i - deleted] <-> v[i];
+ swap(*v, i - deleted, i);
}
}
* * a - The index of the first element
* * b - The index of the second element
*/
+#[inline(always)]
pub fn swap<T>(v: &mut [T], a: uint, b: uint) {
- v[a] <-> v[b];
+ unsafe {
+ // Can't take two mutable loans from one vector, so instead just cast
+ // them to their raw pointers to do the swap
+ let pa: *mut T = ptr::to_mut_unsafe_ptr(&mut v[a]);
+ let pb: *mut T = ptr::to_mut_unsafe_ptr(&mut v[b]);
+ util::swap_ptr(pa, pb);
+ }
}
/// Reverse the order of elements in a vector, in place
pub fn reverse<T>(v: &mut [T]) {
let mut i: uint = 0;
let ln = len::<T>(v);
- while i < ln / 2 { v[i] <-> v[ln - i - 1]; i += 1; }
+ while i < ln / 2 {
+ swap(v, i, ln - i - 1);
+ i += 1;
+ }
}
/// Returns a vector with the order of elements reversed
use sys;
use unstable::intrinsics;
use vec::{UnboxedVecRepr, as_const_buf, as_mut_buf, len, with_capacity};
+ use util;
/// The internal representation of a (boxed) vector
pub struct VecRepr {
pub unsafe fn init_elem<T>(v: &mut [T], i: uint, val: T) {
let mut box = Some(val);
do as_mut_buf(v) |p, _len| {
- let mut box2 = None;
- box2 <-> box;
+ let box2 = util::replace(&mut box, None);
intrinsics::move_val_init(&mut(*ptr::mut_offset(p, i)),
box2.unwrap());
}
//! A double-ended queue implemented as a circular buffer
+use core::util::replace;
+
static initial_capacity: uint = 32u; // 2^5
pub struct Deque<T> {
let mut rv = ~[];
do rv.grow_fn(nelts + 1) |i| {
- let mut element = None;
- element <-> elts[(lo + i) % nelts];
- element
+ replace(&mut elts[(lo + i) % nelts], None)
}
rv
use core::comm::{PortOne, oneshot, send_one};
use core::pipes::recv;
use core::task;
+use core::util::replace;
#[doc = "The future type"]
#[cfg(stage0)]
}
}
{
- let mut state = Evaluating;
- self.state <-> state;
+ let state = replace(&mut self.state, Evaluating);
match state {
Forced(_) | Evaluating => fail!(~"Logic error."),
Pending(f) => {
}
}
{
- let mut state = Evaluating;
- self.state <-> state;
+ let state = replace(&mut self.state, Evaluating);
match state {
Forced(_) | Evaluating => fail!(~"Logic error."),
Pending(f) => {
//! A priority queue implemented with a binary heap
use core::old_iter::BaseIter;
+use core::util::{replace, swap};
#[abi = "rust-intrinsic"]
extern "rust-intrinsic" mod rusti {
/// Pop the greatest item from the queue - fails if empty
fn pop(&mut self) -> T {
let mut item = self.data.pop();
- if !self.is_empty() { item <-> self.data[0]; self.siftdown(0); }
+ if !self.is_empty() {
+ swap(&mut item, &mut self.data[0]);
+ self.siftdown(0);
+ }
item
}
/// Optimized version of a push followed by a pop
fn push_pop(&mut self, mut item: T) -> T {
if !self.is_empty() && self.data[0] > item {
- item <-> self.data[0];
+ swap(&mut item, &mut self.data[0]);
self.siftdown(0);
}
item
/// Optimized version of a pop followed by a push - fails if empty
fn replace(&mut self, mut item: T) -> T {
- item <-> self.data[0];
+ swap(&mut item, &mut self.data[0]);
self.siftdown(0);
item
}
let mut end = q.len();
while end > 1 {
end -= 1;
- q.data[end] <-> q.data[0];
+ vec::swap(q.data, 0, end);
q.siftdown_range(0, end)
}
q.to_vec()
while pos > start {
let parent = (pos - 1) >> 1;
if new > self.data[parent] {
- let mut x = rusti::uninit();
- x <-> self.data[parent];
+ let x = replace(&mut self.data[parent], rusti::uninit());
rusti::move_val_init(&mut self.data[pos], x);
pos = parent;
loop
while pos > start {
let parent = (pos - 1) >> 1;
if new > self.data[parent] {
- let mut x = rusti::init();
- x <-> self.data[parent];
+ let x = replace(&mut self.data[parent], rusti::init());
rusti::move_val_init(&mut self.data[pos], x);
pos = parent;
loop
if right < end && !(self.data[child] > self.data[right]) {
child = right;
}
- let mut x = rusti::uninit();
- x <-> self.data[child];
+ let x = replace(&mut self.data[child], rusti::uninit());
rusti::move_val_init(&mut self.data[pos], x);
pos = child;
child = 2 * pos + 1;
if right < end && !(self.data[child] > self.data[right]) {
child = right;
}
- let mut x = rusti::init();
- x <-> self.data[child];
+ let x = replace(&mut self.data[child], rusti::init());
rusti::move_val_init(&mut self.data[pos], x);
pos = child;
child = 2 * pos + 1;
use core::libc::{c_void, size_t, malloc, free};
use core::unstable::intrinsics;
+use core::util;
struct RcBox<T> {
value: T,
unsafe {
(*self.ptr).count -= 1;
if (*self.ptr).count == 0 {
- let mut x = intrinsics::uninit();
- x <-> *self.ptr;
+ util::replace_ptr(self.ptr, intrinsics::uninit());
free(self.ptr as *c_void)
}
}
unsafe {
(*self.ptr).count -= 1;
if (*self.ptr).count == 0 {
- let mut x = intrinsics::init();
- x <-> *self.ptr;
+ util::replace_ptr(self.ptr, intrinsics::init());
free(self.ptr as *c_void)
}
}
}
}
-#[abi = "rust-intrinsic"]
-extern "rust-intrinsic" mod rusti {
- fn init<T>() -> T;
- #[cfg(not(stage0))]
- fn uninit<T>() -> T;
-}
-
#[deriving(Eq)]
enum Borrow {
Mutable,
unsafe {
(*self.ptr).count -= 1;
if (*self.ptr).count == 0 {
- let mut x = rusti::uninit();
- x <-> *self.ptr;
+ util::replace_ptr(self.ptr, intrinsics::uninit());
free(self.ptr as *c_void)
}
}
unsafe {
(*self.ptr).count -= 1;
if (*self.ptr).count == 0 {
- let mut x = rusti::init();
- x <-> *self.ptr;
+ util::replace_ptr(self.ptr, intrinsics::init());
free(self.ptr as *c_void)
}
}
use core::cmp::{Eq, Ord};
use core::vec::len;
use core::vec;
+use core::util::swap;
type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
#[cfg(stage0)]
fn part<T>(arr: &mut [T], left: uint,
right: uint, pivot: uint, compare_func: Le<T>) -> uint {
- arr[pivot] <-> arr[right];
+ swap(&mut arr[pivot], &mut arr[right]);
let mut storage_index: uint = left;
let mut i: uint = left;
while i < right {
let a: &mut T = &mut arr[i];
let b: &mut T = &mut arr[right];
if compare_func(a, b) {
- arr[i] <-> arr[storage_index];
+ swap(&mut arr[i], &mut arr[storage_index]);
storage_index += 1;
}
i += 1;
}
- arr[storage_index] <-> arr[right];
+ swap(&mut arr[storage_index], &mut arr[right]);
return storage_index;
}
#[cfg(not(stage0))]
fn part<T>(arr: &mut [T], left: uint,
right: uint, pivot: uint, compare_func: Le<T>) -> uint {
- arr[pivot] <-> arr[right];
+ vec::swap(arr, pivot, right);
let mut storage_index: uint = left;
let mut i: uint = left;
while i < right {
if compare_func(&arr[i], &arr[right]) {
- arr[i] <-> arr[storage_index];
+ vec::swap(arr, i, storage_index);
storage_index += 1;
}
i += 1;
}
- arr[storage_index] <-> arr[right];
+ vec::swap(arr, storage_index, right);
return storage_index;
}
j -= 1;
}
if i >= j { break; }
- arr[i] <-> arr[j];
+ vec::swap(arr, i as uint, j as uint);
if arr[i] == v {
p += 1;
- arr[p] <-> arr[i];
+ vec::swap(arr, p as uint, i as uint);
}
if v == arr[j] {
q -= 1;
- arr[j] <-> arr[q];
+ vec::swap(arr, j as uint, q as uint);
}
}
- arr[i] <-> arr[right];
+ vec::swap(arr, i as uint, right as uint);
j = i - 1;
i += 1;
let mut k: int = left;
while k < p {
- arr[k] <-> arr[j];
+ vec::swap(arr, k as uint, j as uint);
k += 1;
j -= 1;
if k == len::<T>(arr) as int { break; }
}
k = right - 1;
while k > q {
- arr[i] <-> arr[k];
+ vec::swap(arr, i as uint, k as uint);
k -= 1;
i += 1;
if k == 0 { break; }
fn reverse_slice<T>(v: &mut [T], start: uint, end:uint) {
let mut i = start;
while i < end / 2 {
- v[i] <-> v[end - i - 1];
+ vec::swap(v, i, end - i - 1);
i += 1;
}
}
let mut len1 = len1;
let mut len2 = len2;
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
if len2 == 0 {
}
if len1 == 1 {
shift_vec(array, dest, c2, len2);
- array[dest+len2] <-> tmp[c1];
+ swap(&mut tmp[c1], &mut array[dest+len2]);
return;
}
loop {
assert!(len1 > 1 && len2 != 0);
if array[c2] < tmp[c1] {
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
count2 += 1; count1 = 0;
if len2 == 0 {
break_outer = true;
}
} else {
- array[dest] <-> tmp[c1];
+ swap(&mut array[dest], &mut tmp[c1]);
dest += 1; c1 += 1; len1 -= 1;
count1 += 1; count2 = 0;
if len1 == 1 {
dest += count1; c1 += count1; len1 -= count1;
if len1 <= 1 { break_outer = true; break; }
}
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
if len2 == 0 { break_outer = true; break; }
dest += count2; c2 += count2; len2 -= count2;
if len2 == 0 { break_outer = true; break; }
}
- array[dest] <-> tmp[c1];
+ swap(&mut array[dest], &mut tmp[c1]);
dest += 1; c1 += 1; len1 -= 1;
if len1 == 1 { break_outer = true; break; }
min_gallop -= 1;
if len1 == 1 {
assert!(len2 > 0);
shift_vec(array, dest, c2, len2);
- array[dest+len2] <-> tmp[c1];
+ swap(&mut array[dest+len2], &mut tmp[c1]);
} else if len1 == 0 {
fail!(~"Comparison violates its contract!");
} else {
let mut len1 = len1;
let mut len2 = len2;
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
if len1 == 0 {
dest -= len1;
c1 -= len1;
shift_vec(array, dest+1, c1+1, len1);
- array[dest] <-> tmp[c2];
+ swap(&mut array[dest], &mut tmp[c2]);
return;
}
loop {
assert!(len1 != 0 && len2 > 1);
if tmp[c2] < array[c1] {
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
count1 += 1; count2 = 0;
if len1 == 0 {
break_outer = true;
}
} else {
- array[dest] <-> tmp[c2];
+ swap(&mut array[dest], &mut tmp[c2]);
dest -= 1; c2 -= 1; len2 -= 1;
count2 += 1; count1 = 0;
if len2 == 1 {
if len1 == 0 { break_outer = true; break; }
}
- array[dest] <-> tmp[c2];
+ swap(&mut array[dest], &mut tmp[c2]);
dest -= 1; c2 -= 1; len2 -= 1;
if len2 == 1 { break_outer = true; break; }
copy_vec(array, dest+1, tmp.slice(c2+1, c2+1+count2));
if len2 <= 1 { break_outer = true; break; }
}
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
if len1 == 0 { break_outer = true; break; }
min_gallop -= 1;
dest -= len1;
c1 -= len1;
shift_vec(array, dest+1, c1+1, len1);
- array[dest] <-> tmp[c2];
+ swap(&mut array[dest], &mut tmp[c2]);
} else if len2 == 0 {
fail!(~"Comparison violates its contract!");
} else {
for 3.times {
let i1 = rng.gen_uint_range(0, n);
let i2 = rng.gen_uint_range(0, n);
- arr[i1] <-> arr[i2];
+ vec::swap(arr, i1, i2);
}
tim_sort(arr); // 3sort
isSorted(arr);
for 3.times {
let i1 = rng.gen_uint_range(0, n);
let i2 = rng.gen_uint_range(0, n);
- arr[i1] <-> arr[i2];
+ vec::swap(arr, i1, i2);
}
tim_sort(arr); // 3sort
isSorted(arr);
use core::cmp::{Eq, Ord};
use core::vec::len;
use core::vec;
+use core::util;
type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
#[cfg(stage0)]
fn part<T>(arr: &mut [T], left: uint,
right: uint, pivot: uint, compare_func: Le<T>) -> uint {
- arr[pivot] <-> arr[right];
+ vec::swap(arr, pivot, right);
let mut storage_index: uint = left;
let mut i: uint = left;
while i < right {
let a: &mut T = &mut arr[i];
let b: &mut T = &mut arr[right];
if compare_func(a, b) {
- arr[i] <-> arr[storage_index];
+ vec::swap(arr, i, storage_index);
storage_index += 1;
}
i += 1;
}
- arr[storage_index] <-> arr[right];
+ vec::swap(arr, storage_index, right);
return storage_index;
}
#[cfg(not(stage0))]
fn part<T>(arr: &mut [T], left: uint,
right: uint, pivot: uint, compare_func: Le<T>) -> uint {
- arr[pivot] <-> arr[right];
+ vec::swap(arr, pivot, right);
let mut storage_index: uint = left;
let mut i: uint = left;
while i < right {
if compare_func(&arr[i], &arr[right]) {
- arr[i] <-> arr[storage_index];
+ vec::swap(arr, i, storage_index);
storage_index += 1;
}
i += 1;
}
- arr[storage_index] <-> arr[right];
+ vec::swap(arr, storage_index, right);
return storage_index;
}
j -= 1;
}
if i >= j { break; }
- arr[i] <-> arr[j];
+ vec::swap(arr, i as uint, j as uint);
if arr[i] == v {
p += 1;
- arr[p] <-> arr[i];
+ vec::swap(arr, p as uint, i as uint);
}
if v == arr[j] {
q -= 1;
- arr[j] <-> arr[q];
+ vec::swap(arr, j as uint, q as uint);
}
}
- arr[i] <-> arr[right];
+ vec::swap(arr, i as uint, right as uint);
j = i - 1;
i += 1;
let mut k: int = left;
while k < p {
- arr[k] <-> arr[j];
+ vec::swap(arr, k as uint, j as uint);
k += 1;
j -= 1;
if k == len::<T>(arr) as int { break; }
}
k = right - 1;
while k > q {
- arr[i] <-> arr[k];
+ vec::swap(arr, i as uint, k as uint);
k -= 1;
i += 1;
if k == 0 { break; }
fn reverse_slice<T>(v: &mut [T], start: uint, end:uint) {
let mut i = start;
while i < end / 2 {
- v[i] <-> v[end - i - 1];
+ vec::swap(v, i, end - i - 1);
i += 1;
}
}
let mut len1 = len1;
let mut len2 = len2;
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
if len2 == 0 {
}
if len1 == 1 {
copy_vec(array, dest, array, c2, len2);
- array[dest+len2] <-> tmp[c1];
+ util::swap(&mut array[dest+len2], &mut tmp[c1]);
return;
}
loop {
assert!(len1 > 1 && len2 != 0);
if array[c2] < tmp[c1] {
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
count2 += 1; count1 = 0;
if len2 == 0 {
break_outer = true;
}
} else {
- array[dest] <-> tmp[c1];
+ util::swap(&mut array[dest], &mut tmp[c1]);
dest += 1; c1 += 1; len1 -= 1;
count1 += 1; count2 = 0;
if len1 == 1 {
dest += count1; c1 += count1; len1 -= count1;
if len1 <= 1 { break_outer = true; break; }
}
- array[dest] <-> array[c2];
+ vec::swap(array, dest, c2);
dest += 1; c2 += 1; len2 -= 1;
if len2 == 0 { break_outer = true; break; }
dest += count2; c2 += count2; len2 -= count2;
if len2 == 0 { break_outer = true; break; }
}
- array[dest] <-> tmp[c1];
+ util::swap(&mut array[dest], &mut tmp[c1]);
dest += 1; c1 += 1; len1 -= 1;
if len1 == 1 { break_outer = true; break; }
min_gallop -= 1;
if len1 == 1 {
assert!(len2 > 0);
copy_vec(array, dest, array, c2, len2);
- array[dest+len2] <-> tmp[c1];
+ util::swap(&mut array[dest+len2], &mut tmp[c1]);
} else if len1 == 0 {
fail!(~"Comparison violates its contract!");
} else {
let mut len1 = len1;
let mut len2 = len2;
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
if len1 == 0 {
dest -= len1;
c1 -= len1;
copy_vec(array, dest+1, array, c1+1, len1);
- array[dest] <-> tmp[c2];
+ util::swap(&mut array[dest], &mut tmp[c2]);
return;
}
loop {
assert!(len1 != 0 && len2 > 1);
if tmp[c2] < array[c1] {
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
count1 += 1; count2 = 0;
if len1 == 0 {
break_outer = true;
}
} else {
- array[dest] <-> tmp[c2];
+ util::swap(&mut array[dest], &mut tmp[c2]);
dest -= 1; c2 -= 1; len2 -= 1;
count2 += 1; count1 = 0;
if len2 == 1 {
if len1 == 0 { break_outer = true; break; }
}
- array[dest] <-> tmp[c2];
+ util::swap(&mut array[dest], &mut tmp[c2]);
dest -= 1; c2 -= 1; len2 -= 1;
if len2 == 1 { break_outer = true; break; }
copy_vec(array, dest+1, tmp, c2+1, count2);
if len2 <= 1 { break_outer = true; break; }
}
- array[dest] <-> array[c1];
+ vec::swap(array, dest, c1);
dest -= 1; c1 -= 1; len1 -= 1;
if len1 == 0 { break_outer = true; break; }
min_gallop -= 1;
dest -= len1;
c1 -= len1;
copy_vec(array, dest+1, array, c1+1, len1);
- array[dest] <-> tmp[c2];
+ util::swap(&mut array[dest], &mut tmp[c2]);
} else if len2 == 0 {
fail!(~"Comparison violates its contract!");
} else {
for 3.times {
let i1 = rng.gen_uint_range(0, n);
let i2 = rng.gen_uint_range(0, n);
- arr[i1] <-> arr[i2];
+ vec::swap(arr, i1, i2);
}
tim_sort(arr); // 3sort
isSorted(arr);
for 3.times {
let i1 = rng.gen_uint_range(0, n);
let i2 = rng.gen_uint_range(0, n);
- arr[i1] <-> arr[i2];
+ vec::swap(arr, i1, i2);
}
tim_sort(arr); // 3sort
isSorted(arr);
//! `TotalOrd`.
use core::iterator::*;
-use core::util::replace;
+use core::util::{swap, replace};
// This is implemented as an AA tree, which is a simplified variation of
// a red-black tree where where red (horizontal) nodes can only be added
fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
if node.left.map_default(false, |x| x.level == node.level) {
let mut save = node.left.swap_unwrap();
- node.left <-> save.right; // save.right now None
- *node <-> save;
+ swap(&mut node.left, &mut save.right); // save.right now None
+ swap(node, &mut save);
node.right = Some(save);
}
}
if node.right.map_default(false,
|x| x.right.map_default(false, |y| y.level == node.level)) {
let mut save = node.right.swap_unwrap();
- node.right <-> save.left; // save.left now None
+ swap(&mut node.right, &mut save.left); // save.left now None
save.level += 1;
- *node <-> save;
+ swap(node, &mut save);
node.left = Some(save);
}
}
fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
key: &K) -> Option<V> {
fn heir_swap<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>,
- child: &mut Option<~TreeNode<K, V>>) {
+ child: &mut Option<~TreeNode<K, V>>) {
// *could* be done without recursion, but it won't borrow check
for child.each_mut |x| {
if x.right.is_some() {
heir_swap(node, &mut x.right);
} else {
- node.key <-> x.key;
- node.value <-> x.value;
+ swap(&mut node.key, &mut x.key);
+ swap(&mut node.value, &mut x.value);
}
}
}
if left.right.is_some() {
heir_swap(save, &mut left.right);
} else {
- save.key <-> left.key;
- save.value <-> left.value;
+ swap(&mut save.key, &mut left.key);
+ swap(&mut save.value, &mut left.value);
}
save.left = Some(left);
(remove(&mut save.left, key), true)
use core::pipes::recv;
use core::run;
use core::to_bytes;
+use core::util::replace;
/**
*
_ => {
let (port, chan) = oneshot();
- let mut blk = None;
- blk <-> bo;
- let blk = blk.unwrap();
+ let blk = replace(&mut bo, None).unwrap();
let chan = Cell(chan);
do task::spawn {
Decodable<json::Decoder>>( // FIXME(#5121)
w: Work<T>) -> T {
let mut ww = w;
- let mut s = None;
-
- ww.res <-> s;
+ let s = replace(&mut ww.res, None);
match s {
None => fail!(),
use std::time::precise_time_s;
use core::rand::RngUtil;
+use core::util;
macro_rules! bench (
($id:ident) => (maybe_run_test(argv, stringify!($id).to_owned(), $id))
v.push_all(rv);
}
else {
- v <-> rv;
+ util::swap(&mut v, &mut rv);
v.push_all(rv);
}
}
use core::cell::Cell;
use core::pipes::recv;
+use core::util;
use std::time;
use std::future;
// Send/Receive lots of messages.
for uint::range(0, count) |j| {
//error!("task %?, iter %?", i, j);
- let mut num_chan2 = None;
- let mut num_port2 = None;
- num_chan2 <-> num_chan;
- num_port2 <-> num_port;
+ let num_chan2 = replace(&mut num_chan, None);
+ let num_port2 = replace(&mut num_port, None);
num_chan = Some(ring::client::num(num_chan2.unwrap(), i * j));
let port = num_port2.unwrap();
match recv(port) {
use core::io::ReaderUtil;
use core::comm::{stream, Port, Chan};
use core::cmp::Ord;
+use core::util;
// given a map, print a sorted version of it
fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
let mut from_child = ~[];
let to_child = vec::mapi(sizes, |ii, sz| {
let sz = *sz;
- let mut stream = None;
- stream <-> streams[ii];
+ let stream = util::replace(&mut streams[ii], None);
let (from_child_, to_parent_) = stream.unwrap();
from_child.push(from_child_);
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn test1() {
- let v: int;
- let mut w: int;
- v = 1; //~ NOTE prior assignment occurs here
- w = 2;
- v <-> w; //~ ERROR re-assignment of immutable variable
-}
-
-fn test2() {
- let v: int;
- let mut w: int;
- v = 1; //~ NOTE prior assignment occurs here
- w = 2;
- w <-> v; //~ ERROR re-assignment of immutable variable
-}
-
-fn main() {
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let mut x = 3;
- let y;
- x <-> y; //~ ERROR use of possibly uninitialized variable: `y`
- copy x;
-}
fn f120() {
let x = ~[~"hi", ~"ho"];
- x[0] <-> x[1];
+ vec::swap(x, 0, 1);
touch(&x[0]);
touch(&x[1]);
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- 5 <-> 3;
- //~^ ERROR cannot assign
- //~^^ ERROR cannot assign
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
struct Ints {sum: ~int, values: ~[int]}
fn add_int(x: &mut Ints, v: int) {
*x.sum += v;
let mut values = ~[];
- x.values <-> values;
+ util::swap(&mut values, &mut x.values);
values.push(v);
- x.values <-> values;
+ util::swap(&mut values, &mut x.values);
}
fn iter_ints(x: &Ints, f: &fn(x: &int) -> bool) -> bool {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
// tjc: I don't know why
pub mod pipes {
+ use core::util;
use core::cast::{forget, transmute};
pub struct Stuff<T> {
match old_state {
empty | blocked => { task::yield(); }
full => {
- let mut payload = None;
- payload <-> (*p).payload;
+ let payload = util::replace(&mut p.payload, None);
return Some(payload.unwrap())
}
terminated => {
fn finalize(&self) {
unsafe {
if self.p != None {
- let mut p = None;
let self_p: &mut Option<*packet<T>> =
cast::transmute(&self.p);
- p <-> *self_p;
+ let p = util::replace(self_p, None);
sender_terminate(p.unwrap())
}
}
pub impl<T:Owned> send_packet<T> {
fn unwrap(&mut self) -> *packet<T> {
- let mut p = None;
- p <-> self.p;
- p.unwrap()
+ util::replace(&mut self.p, None).unwrap()
}
}
fn finalize(&self) {
unsafe {
if self.p != None {
- let mut p = None;
let self_p: &mut Option<*packet<T>> =
cast::transmute(&self.p);
- p <-> *self_p;
+ let p = util::replace(self_p, None);
receiver_terminate(p.unwrap())
}
}
pub impl<T:Owned> recv_packet<T> {
fn unwrap(&mut self) -> *packet<T> {
- let mut p = None;
- p <-> self.p;
- p.unwrap()
+ util::replace(&mut self.p, None).unwrap()
}
}
pub mod pingpong {
use core::cast;
use core::ptr;
+ use core::util;
pub struct ping(::pipes::send_packet<pong>);
pub struct pong(::pipes::send_packet<ping>);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
pub fn main() {
let mut x = 4;
}
}
let mut y = 4;
- y <-> x;
+ util::swap(&mut y, &mut x);
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
pub fn main() {
let mut x = 3; let mut y = 7;
- x <-> y; assert!((x == 7)); assert!((y == 3));
+ util::swap(&mut x, &mut y);
+ assert!((x == 7)); assert!((y == 3));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn swap<T>(v: &mut [T], i: int, j: int) { v[i] <-> v[j]; }
+use core::util;
pub fn main() {
let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6];
- swap(a, 2, 4);
+ vec::swap(a, 2, 4);
assert!((a[2] == 4));
assert!((a[4] == 2));
let mut n = 42;
- n <-> a[0];
+ util::swap(&mut n, &mut a[0]);
assert!((a[0] == 42));
assert!((n == 0));
}
// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
+use core::util;
+
pub fn main() {
let mut test = TestDescAndFn {
desc: TestDesc {
}
fn do_swap(test: &mut TestDescAndFn) {
- *test <-> *test;
+ unsafe {
+ util::swap_ptr(ptr::to_mut_unsafe_ptr(test),
+ ptr::to_mut_unsafe_ptr(test));
+ }
}
pub enum TestName {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
pub fn main() {
let mut i = ~100;
let mut j = ~200;
- i <-> j;
+ util::swap(&mut i, &mut j);
assert!(i == ~200);
assert!(j == ~100);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use core::util;
+
// Just a grab bag of stuff that you wouldn't want to actually write.
fn strange() -> bool { let _x: bool = return true; }
let mut _y = (_x = 0) == (_x = 0);
let mut _z = (_x = 0) < (_x = 0);
let _a = (_x += 0) == (_x = 0);
- let _b = (_y <-> _z) == (_y <-> _z);
+ let _b = util::swap(&mut _y, &mut _z) == util::swap(&mut _y, &mut _z);
}
fn canttouchthis() -> uint {
projects / rust.git / commitdiff