use vec::Vec;
use core::mem;
+use core::ptr;
use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
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())
}
}