090040bf40
for `~str`/`~[]`. Note that `~self` still remains, since I forgot to add support for `Box<self>` before the snapshot. How to update your code: * Instead of `~EXPR`, you should write `box EXPR`. * Instead of `~TYPE`, you should write `Box<Type>`. * Instead of `~PATTERN`, you should write `box PATTERN`. [breaking-change]
132 lines
3.6 KiB
Rust
132 lines
3.6 KiB
Rust
// Copyright 2013 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.
|
|
|
|
use option::Option;
|
|
use owned::Box;
|
|
use rt::task::Task;
|
|
use rt::local_ptr;
|
|
|
|
/// Encapsulates some task-local data.
|
|
pub trait Local<Borrowed> {
|
|
fn put(value: Box<Self>);
|
|
fn take() -> Box<Self>;
|
|
fn try_take() -> Option<Box<Self>>;
|
|
fn exists(unused_value: Option<Self>) -> bool;
|
|
fn borrow(unused_value: Option<Self>) -> Borrowed;
|
|
unsafe fn unsafe_take() -> Box<Self>;
|
|
unsafe fn unsafe_borrow() -> *mut Self;
|
|
unsafe fn try_unsafe_borrow() -> Option<*mut Self>;
|
|
}
|
|
|
|
#[allow(visible_private_types)]
|
|
impl Local<local_ptr::Borrowed<Task>> for Task {
|
|
#[inline]
|
|
fn put(value: Box<Task>) { unsafe { local_ptr::put(value) } }
|
|
#[inline]
|
|
fn take() -> Box<Task> { unsafe { local_ptr::take() } }
|
|
#[inline]
|
|
fn try_take() -> Option<Box<Task>> { unsafe { local_ptr::try_take() } }
|
|
fn exists(_: Option<Task>) -> bool { local_ptr::exists() }
|
|
#[inline]
|
|
fn borrow(_: Option<Task>) -> local_ptr::Borrowed<Task> {
|
|
unsafe {
|
|
local_ptr::borrow::<Task>()
|
|
}
|
|
}
|
|
#[inline]
|
|
unsafe fn unsafe_take() -> Box<Task> { local_ptr::unsafe_take() }
|
|
#[inline]
|
|
unsafe fn unsafe_borrow() -> *mut Task { local_ptr::unsafe_borrow() }
|
|
#[inline]
|
|
unsafe fn try_unsafe_borrow() -> Option<*mut Task> {
|
|
local_ptr::try_unsafe_borrow()
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use option::{None, Option};
|
|
use unstable::run_in_bare_thread;
|
|
use super::*;
|
|
use owned::Box;
|
|
use rt::task::Task;
|
|
|
|
#[test]
|
|
fn thread_local_task_smoke_test() {
|
|
run_in_bare_thread(proc() {
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
let task: Box<Task> = Local::take();
|
|
cleanup_task(task);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn thread_local_task_two_instances() {
|
|
run_in_bare_thread(proc() {
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
let task: Box<Task> = Local::take();
|
|
cleanup_task(task);
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
let task: Box<Task> = Local::take();
|
|
cleanup_task(task);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn borrow_smoke_test() {
|
|
run_in_bare_thread(proc() {
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
|
|
unsafe {
|
|
let _task: *mut Task = Local::unsafe_borrow();
|
|
}
|
|
let task: Box<Task> = Local::take();
|
|
cleanup_task(task);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn borrow_with_return() {
|
|
run_in_bare_thread(proc() {
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
|
|
{
|
|
let _ = Local::borrow(None::<Task>);
|
|
}
|
|
|
|
let task: Box<Task> = Local::take();
|
|
cleanup_task(task);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn try_take() {
|
|
run_in_bare_thread(proc() {
|
|
let task = box Task::new();
|
|
Local::put(task);
|
|
|
|
let t: Box<Task> = Local::try_take().unwrap();
|
|
let u: Option<Box<Task>> = Local::try_take();
|
|
assert!(u.is_none());
|
|
|
|
cleanup_task(t);
|
|
});
|
|
}
|
|
|
|
fn cleanup_task(mut t: Box<Task>) {
|
|
t.destroyed = true;
|
|
}
|
|
|
|
}
|