2012-08-21 17:55:17 -05:00
|
|
|
/*!
|
|
|
|
|
|
|
|
Module for wrapping freezable data structures in managed boxes.
|
|
|
|
Normally freezable data structures require an unaliased reference,
|
|
|
|
such as `T` or `~T`, so that the compiler can track when they are
|
2012-08-21 19:14:40 -05:00
|
|
|
being mutated. The `managed<T>` type converts these static checks into
|
2012-08-21 17:55:17 -05:00
|
|
|
dynamic checks: your program will fail if you attempt to perform
|
|
|
|
mutation when the data structure should be immutable.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#[forbid(deprecated_mode)];
|
|
|
|
#[forbid(deprecated_pattern)];
|
|
|
|
|
2012-09-04 13:12:17 -05:00
|
|
|
use util::with;
|
2012-09-18 19:34:08 -05:00
|
|
|
use cast::transmute_immut;
|
2012-08-21 17:55:17 -05:00
|
|
|
|
2012-09-10 18:34:31 -05:00
|
|
|
export Mut;
|
2012-08-21 17:55:17 -05:00
|
|
|
|
|
|
|
enum Mode { ReadOnly, Mutable, Immutable }
|
|
|
|
|
|
|
|
struct Data<T> {
|
2012-09-07 16:50:47 -05:00
|
|
|
priv mut value: T,
|
|
|
|
priv mut mode: Mode
|
2012-08-21 17:55:17 -05:00
|
|
|
}
|
|
|
|
|
2012-09-10 18:34:31 -05:00
|
|
|
type Mut<T> = Data<T>;
|
2012-08-21 17:55:17 -05:00
|
|
|
|
2012-09-10 18:34:31 -05:00
|
|
|
fn Mut<T>(+t: T) -> Mut<T> {
|
|
|
|
Data {value: t, mode: ReadOnly}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn unwrap<T>(+m: Mut<T>) -> T {
|
|
|
|
// Borrowck should prevent us from calling unwrap while the value
|
|
|
|
// is in use, as that would be a move from a borrowed value.
|
|
|
|
assert (m.mode as uint) == (ReadOnly as uint);
|
2012-09-10 20:28:00 -05:00
|
|
|
let Data {value, mode: _} <- m;
|
2012-09-10 18:34:31 -05:00
|
|
|
return move value;
|
2012-08-21 17:55:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> Data<T> {
|
|
|
|
fn borrow_mut<R>(op: &fn(t: &mut T) -> R) -> R {
|
|
|
|
match self.mode {
|
2012-09-10 18:34:31 -05:00
|
|
|
Immutable => fail fmt!("%? currently immutable",
|
|
|
|
self.value),
|
|
|
|
ReadOnly | Mutable => {}
|
2012-08-21 17:55:17 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
do with(&mut self.mode, Mutable) {
|
|
|
|
op(&mut self.value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn borrow_const<R>(op: &fn(t: &const T) -> R) -> R {
|
|
|
|
op(&const self.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn borrow_imm<R>(op: &fn(t: &T) -> R) -> R {
|
|
|
|
match self.mode {
|
|
|
|
Mutable => fail fmt!("%? currently mutable",
|
|
|
|
self.value),
|
|
|
|
ReadOnly | Immutable => {}
|
|
|
|
}
|
|
|
|
|
|
|
|
do with(&mut self.mode, Immutable) {
|
|
|
|
op(unsafe{transmute_immut(&mut self.value)})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-08-21 19:14:40 -05:00
|
|
|
|
|
|
|
#[test]
|
2012-08-21 22:49:35 -05:00
|
|
|
#[ignore(cfg(windows))]
|
2012-08-21 19:14:40 -05:00
|
|
|
#[should_fail]
|
|
|
|
fn test_mut_in_imm() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_imm |_p| {
|
|
|
|
do m.borrow_mut |_q| {
|
|
|
|
// should not be permitted
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2012-08-21 22:49:35 -05:00
|
|
|
#[ignore(cfg(windows))]
|
2012-08-21 19:14:40 -05:00
|
|
|
#[should_fail]
|
|
|
|
fn test_imm_in_mut() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_mut |_p| {
|
|
|
|
do m.borrow_imm |_q| {
|
|
|
|
// should not be permitted
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_const_in_mut() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_mut |p| {
|
|
|
|
do m.borrow_const |q| {
|
|
|
|
assert *p == *q;
|
|
|
|
*p += 1;
|
|
|
|
assert *p == *q;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_mut_in_const() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_const |p| {
|
|
|
|
do m.borrow_mut |q| {
|
|
|
|
assert *p == *q;
|
|
|
|
*q += 1;
|
|
|
|
assert *p == *q;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_imm_in_const() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_const |p| {
|
|
|
|
do m.borrow_imm |q| {
|
|
|
|
assert *p == *q;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_const_in_imm() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_imm |p| {
|
|
|
|
do m.borrow_const |q| {
|
|
|
|
assert *p == *q;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[test]
|
2012-08-21 22:49:35 -05:00
|
|
|
#[ignore(cfg(windows))]
|
2012-08-21 19:14:40 -05:00
|
|
|
#[should_fail]
|
|
|
|
fn test_mut_in_imm_in_const() {
|
2012-09-10 18:34:31 -05:00
|
|
|
let m = @Mut(1);
|
2012-08-21 19:14:40 -05:00
|
|
|
do m.borrow_const |_p| {
|
|
|
|
do m.borrow_imm |_q| {
|
|
|
|
do m.borrow_mut |_r| {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|