use vec::Vec;
use core::mem;
+use core::ptr;
-use sync::atomic::{Ordering, AtomicUint};
+use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
- channels: AtomicUint,
+ channels: AtomicUsize,
lock: Mutex<State<T>>,
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
- channels: AtomicUint::new(1),
+ channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
cap: cap,
canceled: None,
queue: Queue {
- head: 0 as *mut Node,
- tail: 0 as *mut Node,
+ head: ptr::null_mut(),
+ tail: ptr::null_mut(),
},
buf: Buffer {
buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
// wait until a send slot is available, returning locked access to
// the channel state.
fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
- let mut node = Node { token: None, next: 0 as *mut Node };
+ let mut node = Node { token: None, next: ptr::null_mut() };
loop {
let mut guard = self.lock.lock().unwrap();
// are we ready to go?
Vec::new()
};
let mut queue = mem::replace(&mut guard.queue, Queue {
- head: 0 as *mut Node,
- tail: 0 as *mut Node,
+ head: ptr::null_mut(),
+ tail: ptr::null_mut(),
});
let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
fn enqueue(&mut self, node: &mut Node) -> WaitToken {
let (wait_token, signal_token) = blocking::tokens();
node.token = Some(signal_token);
- node.next = 0 as *mut Node;
+ node.next = ptr::null_mut();
if self.tail.is_null() {
self.head = node as *mut Node;
let node = self.head;
self.head = unsafe { (*node).next };
if self.head.is_null() {
- self.tail = 0 as *mut Node;
+ self.tail = ptr::null_mut();
}
unsafe {
- (*node).next = 0 as *mut Node;
+ (*node).next = ptr::null_mut();
Some((*node).token.take().unwrap())
}
}