// 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use core::prelude::*; use alloc::boxed::Box; use local_ptr; use task::Task; /// Encapsulates some task-local data. pub trait Local { fn put(value: Box); fn take() -> Box; fn try_take() -> Option>; fn exists(unused_value: Option) -> bool; fn borrow(unused_value: Option) -> Borrowed; unsafe fn unsafe_take() -> Box; unsafe fn unsafe_borrow() -> *mut Self; unsafe fn try_unsafe_borrow() -> Option<*mut Self>; } impl Local> for Task { #[inline] fn put(value: Box) { unsafe { local_ptr::put(value) } } #[inline] fn take() -> Box { unsafe { local_ptr::take() } } #[inline] fn try_take() -> Option> { unsafe { local_ptr::try_take() } } fn exists(_: Option) -> bool { local_ptr::exists() } #[inline] fn borrow(_: Option) -> local_ptr::Borrowed { unsafe { local_ptr::borrow::() } } #[inline] unsafe fn unsafe_take() -> Box { 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 std::prelude::*; use thread::Thread; use super::*; use task::Task; #[test] fn thread_local_task_smoke_test() { Thread::start(proc() { let task = box Task::new(None, None); Local::put(task); let task: Box = Local::take(); cleanup_task(task); }).join(); } #[test] fn thread_local_task_two_instances() { Thread::start(proc() { let task = box Task::new(None, None); Local::put(task); let task: Box = Local::take(); cleanup_task(task); let task = box Task::new(None, None); Local::put(task); let task: Box = Local::take(); cleanup_task(task); }).join(); } #[test] fn borrow_smoke_test() { Thread::start(proc() { let task = box Task::new(None, None); Local::put(task); unsafe { let _task: *mut Task = Local::unsafe_borrow(); } let task: Box = Local::take(); cleanup_task(task); }).join(); } #[test] fn borrow_with_return() { Thread::start(proc() { let task = box Task::new(None, None); Local::put(task); { let _ = Local::borrow(None::); } let task: Box = Local::take(); cleanup_task(task); }).join(); } #[test] fn try_take() { Thread::start(proc() { let task = box Task::new(None, None); Local::put(task); let t: Box = Local::try_take().unwrap(); let u: Option> = Local::try_take(); assert!(u.is_none()); cleanup_task(t); }).join(); } fn cleanup_task(t: Box) { t.drop(); } }