---

yaml
---
r: 95676
b: refs/heads/dist-snap
c: 89c9120
h: refs/heads/master
v: v3

Author: toffaletti

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: c372fa55560f1cdfdcb566f3027689ba88c46da5
+refs/heads/dist-snap: 89c91208a7e1e2a5ce77dcb2032601393d861128
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/rt/mpsc_queue.rs

@@ -83,24 +83,28 @@ impl<T: Send> fmt::Default for Queue<T> {
     }
 }
 
-impl<T: Send> Queue<T> {
-    pub fn new() -> Queue<T> {
-        let mut q = Queue{state: UnsafeArc::new(State {
+impl<T: Send> State<T> {
+    pub fn new() -> State<T> {
+        let mut state = State {
             pad0: [0, ..64],
             head: AtomicPtr::new(mut_null()),
             pad1: [0, ..64],
             stub: Default::default(),
             pad2: [0, ..64],
             tail: mut_null(),
             pad3: [0, ..64],
-        })};
-        let stub = q.get_stub_unsafe();
-        q.get_head().store(stub, Relaxed);
-        q.set_tail(stub);
-        q
+        };
+        let stub = state.get_stub_unsafe();
+        state.head.store(stub, Relaxed);
+        state.tail = stub;
+        state
     }
 
-    pub fn push(&mut self, value: T) {
+    fn get_stub_unsafe(&mut self) -> *mut Node<T> {
+        unsafe { to_mut_unsafe_ptr(&mut self.stub) }
+    }
+
+    fn push(&mut self, value: T) {
         unsafe {
             let node = cast::transmute(~Node::new(value));
             self.push_node(node);
@@ -110,65 +114,63 @@ impl<T: Send> Queue<T> {
     fn push_node(&mut self, node: *mut Node<T>) {
         unsafe {
             (*node).next.store(mut_null(), Release);
-            let prev = self.get_head().swap(node, Relaxed);
+            let prev = self.head.swap(node, Relaxed);
             (*prev).next.store(node, Release);
         }
     }
 
-    fn get_stub_unsafe(&mut self) -> *mut Node<T> {
-        unsafe { to_mut_unsafe_ptr(&mut (*self.state.get()).stub) }
-    }
-
-    fn get_head(&mut self) -> &mut AtomicPtr<Node<T>> {
-        unsafe { &mut (*self.state.get()).head }
-    }
-
-    fn get_tail(&mut self) -> *mut Node<T> {
-        unsafe { (*self.state.get()).tail }
-    }
-
-    fn set_tail(&mut self, tail: *mut Node<T>) {
-        unsafe { (*self.state.get()).tail = tail }
-    }
-
-    pub fn casual_pop(&mut self) -> Option<T> {
-        self.pop()
-    }
-
-    pub fn pop(&mut self) -> Option<T> {
+    fn pop(&mut self) -> Option<T> {
         unsafe {
-            let mut tail = self.get_tail();
+            let mut tail = self.tail;
             let mut next = (*tail).next.load(Acquire);
             let stub = self.get_stub_unsafe();
             if tail == stub {
                 if mut_null() == next {
                     return None
                 }
-                self.set_tail(next);
+                self.tail = next;
                 tail = next;
                 next = (*next).next.load(Acquire);
             }
             if next != mut_null() {
                 let tail: ~Node<T> = cast::transmute(tail);
-                self.set_tail(next);
+                self.tail = next;
                 return tail.value
             }
-            let head = self.get_head().load(Relaxed);
+            let head = self.head.load(Relaxed);
             if tail != head {
                 return None
             }
             self.push_node(stub);
             next = (*tail).next.load(Acquire);
             if next != mut_null() {
                 let tail: ~Node<T> = cast::transmute(tail);
-                self.set_tail(next);
+                self.tail = next;
                 return tail.value
             }
         }
         None
     }
 }
 
+impl<T: Send> Queue<T> {
+    pub fn new() -> Queue<T> {
+        Queue{state: UnsafeArc::new(State::new())}
+    }
+
+    pub fn push(&mut self, value: T) {
+        unsafe { (*self.state.get()).push(value) }
+    }
+
+    pub fn casual_pop(&mut self) -> Option<T> {
+        unsafe { (*self.state.get()).pop() }
+    }
+
+    pub fn pop(&mut self) -> Option<T> {
+        unsafe{ (*self.state.get()).pop() }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use prelude::*;