use sync::Arc;
use fmt;
+#[cfg(stage0)] // NOTE remove use after next snapshot
use marker;
use mem;
use cell::UnsafeCell;
#[stable]
#[cfg(stage0)] // NOTE remove impl after next snapshot
pub struct SyncSender<T> {
- inner: Arc<RacyCell<sync::Packet<T>>>,
+ inner: Arc<UnsafeCell<sync::Packet<T>>>,
// can't share in an arc
_marker: marker::NoSync,
}
#[stable]
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
pub struct SyncSender<T> {
- inner: Arc<RacyCell<sync::Packet<T>>>,
+ inner: Arc<UnsafeCell<sync::Packet<T>>>,
}
+unsafe impl<T:Send> Send for SyncSender<T> {}
+
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
-impl<T> !marker::Sync for SyncSender<T> {}
+impl<T> !Sync for SyncSender<T> {}
/// An error returned from the `send` function on channels.
///
}
enum Flavor<T> {
- Oneshot(Arc<RacyCell<oneshot::Packet<T>>>),
- Stream(Arc<RacyCell<stream::Packet<T>>>),
- Shared(Arc<RacyCell<shared::Packet<T>>>),
- Sync(Arc<RacyCell<sync::Packet<T>>>),
+ Oneshot(Arc<UnsafeCell<oneshot::Packet<T>>>),
+ Stream(Arc<UnsafeCell<stream::Packet<T>>>),
+ Shared(Arc<UnsafeCell<shared::Packet<T>>>),
+ Sync(Arc<UnsafeCell<sync::Packet<T>>>),
}
#[doc(hidden)]
/// ```
#[stable]
pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
- let a = Arc::new(RacyCell::new(oneshot::Packet::new()));
+ let a = Arc::new(UnsafeCell::new(oneshot::Packet::new()));
(Sender::new(Flavor::Oneshot(a.clone())), Receiver::new(Flavor::Oneshot(a)))
}
/// ```
#[stable]
pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) {
- let a = Arc::new(RacyCell::new(sync::Packet::new(bound)));
+ let a = Arc::new(UnsafeCell::new(sync::Packet::new(bound)));
(SyncSender::new(a.clone()), Receiver::new(Flavor::Sync(a)))
}
return (*p).send(t).map_err(SendError);
} else {
let a =
- Arc::new(RacyCell::new(stream::Packet::new()));
+ Arc::new(UnsafeCell::new(stream::Packet::new()));
let rx = Receiver::new(Flavor::Stream(a.clone()));
match (*p).upgrade(rx) {
oneshot::UpSuccess => {
fn clone(&self) -> Sender<T> {
let (packet, sleeper, guard) = match *unsafe { self.inner() } {
Flavor::Oneshot(ref p) => {
- let a = Arc::new(RacyCell::new(shared::Packet::new()));
+ let a = Arc::new(UnsafeCell::new(shared::Packet::new()));
unsafe {
let guard = (*a.get()).postinit_lock();
let rx = Receiver::new(Flavor::Shared(a.clone()));
}
}
Flavor::Stream(ref p) => {
- let a = Arc::new(RacyCell::new(shared::Packet::new()));
+ let a = Arc::new(UnsafeCell::new(shared::Packet::new()));
unsafe {
let guard = (*a.get()).postinit_lock();
let rx = Receiver::new(Flavor::Shared(a.clone()));
impl<T: Send> SyncSender<T> {
#[cfg(stage0)] // NOTE remove impl after next snapshot
- fn new(inner: Arc<RacyCell<sync::Packet<T>>>) -> SyncSender<T> {
+ fn new(inner: Arc<UnsafeCell<sync::Packet<T>>>) -> SyncSender<T> {
SyncSender { inner: inner, _marker: marker::NoSync }
}
#[cfg(not(stage0))] // NOTE remove cfg after next snapshot
- fn new(inner: Arc<RacyCell<sync::Packet<T>>>) -> SyncSender<T> {
+ fn new(inner: Arc<UnsafeCell<sync::Packet<T>>>) -> SyncSender<T> {
SyncSender { inner: inner }
}
}
}
-/// A version of `UnsafeCell` intended for use in concurrent data
-/// structures (for example, you might put it in an `Arc`).
-struct RacyCell<T>(pub UnsafeCell<T>);
-
-impl<T> RacyCell<T> {
-
- fn new(value: T) -> RacyCell<T> {
- RacyCell(UnsafeCell { value: value })
- }
-
- unsafe fn get(&self) -> *mut T {
- self.0.get()
- }
-
-}
-
-unsafe impl<T:Send> Send for RacyCell<T> { }
-
-unsafe impl<T> Sync for RacyCell<T> { } // Oh dear
-
impl<T> fmt::Show for SendError<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
"sending on a closed channel".fmt(f)