---

yaml
---
r: 142743
b: refs/heads/try2
c: 24d2d7b
h: refs/heads/master
i:
  142741: 42ce9a5
  142739: 94c024f
  142735: 03b144d
v: v3

Author: blake2-ppc

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7052371e39268c08067048654a4e115ac86cc51b
+refs/heads/try2: 24d2d7b5bb4b046429f293ff5c2cde4d14dfac8b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/dlist.rs

@@ -10,13 +10,14 @@
 // Backlinks over List::prev are raw pointers that form a full chain in
 // the reverse direction.
 
-
 use std::cast;
 use std::cmp;
 use std::ptr;
 use std::util;
 use std::iterator::FromIterator;
 
+use container::Deque;
+
 /// A doubly-linked list
 pub struct List<T> {
     priv length: uint,
@@ -124,36 +125,30 @@ impl<T> Mutable for List<T> {
     }
 }
 
-impl<T> List<T> {
-    /// Create an empty List
-    #[inline]
-    pub fn new() -> List<T> {
-        List{list_head: None, list_tail: Rawlink::none(), length: 0}
-    }
-
+impl<T> Deque<T> for List<T> {
     /// Provide a reference to the front element, or None if the list is empty
-    pub fn peek_front<'a>(&'a self) -> Option<&'a T> {
+    fn front<'a>(&'a self) -> Option<&'a T> {
         self.list_head.chain_ref(|x| Some(&x.value))
     }
 
     /// Provide a mutable reference to the front element, or None if the list is empty
-    pub fn peek_front_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn front_mut<'a>(&'a mut self) -> Option<&'a mut T> {
         match self.list_head {
             None => None,
             Some(ref mut head) => Some(&mut head.value),
         }
     }
 
     /// Provide a reference to the back element, or None if the list is empty
-    pub fn peek_back<'a>(&'a self) -> Option<&'a T> {
+    fn back<'a>(&'a self) -> Option<&'a T> {
         match self.list_tail.resolve_immut() {
             None => None,
             Some(tail) => Some(&tail.value),
         }
     }
 
     /// Provide a mutable reference to the back element, or None if the list is empty
-    pub fn peek_back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
         match self.list_tail.resolve() {
             None => None,
             Some(tail) => Some(&mut tail.value),
@@ -163,7 +158,7 @@ impl<T> List<T> {
     /// Add an element last in the list
     ///
     /// O(1)
-    pub fn push_back(&mut self, elt: T) {
+    fn push_back(&mut self, elt: T) {
         match self.list_tail.resolve() {
             None => return self.push_front(elt),
             Some(tail) => {
@@ -179,7 +174,7 @@ impl<T> List<T> {
     ///
     /// O(1)
     #[inline]
-    pub fn pop_back(&mut self) -> Option<T> {
+    fn pop_back(&mut self) -> Option<T> {
         match self.list_tail.resolve() {
             None => None,
             Some(tail) => {
@@ -202,7 +197,7 @@ impl<T> List<T> {
     /// Add an element first in the list
     ///
     /// O(1)
-    pub fn push_front(&mut self, elt: T) {
+    fn push_front(&mut self, elt: T) {
         let mut new_head = ~Node{value: elt, next: None, prev: Rawlink::none()};
         match self.list_head {
             None => {
@@ -221,7 +216,7 @@ impl<T> List<T> {
     /// Remove the first element and return it, or None if the list is empty
     ///
     /// O(1)
-    pub fn pop_front(&mut self) -> Option<T> {
+    fn pop_front(&mut self) -> Option<T> {
         match util::replace(&mut self.list_head, None) {
             None => None,
             Some(old_head) => {
@@ -239,6 +234,14 @@ impl<T> List<T> {
             }
         }
     }
+}
+
+impl<T> List<T> {
+    /// Create an empty List
+    #[inline]
+    pub fn new() -> List<T> {
+        List{list_head: None, list_tail: Rawlink::none(), length: 0}
+    }
 
     /// Add all elements from `other` to the end of the list
     ///
@@ -292,7 +295,7 @@ impl<T> List<T> {
         {
             let mut it = self.mut_iter();
             loop {
-                match (it.next(), other.peek_front()) {
+                match (it.next(), other.front()) {
                     (None   , _      ) => break,
                     (_      , None   ) => return,
                     (Some(x), Some(y)) => if f(x, y) { loop }
@@ -462,7 +465,7 @@ impl<'self, A> ListInsertion<A> for MutForwardIterator<'self, A> {
 
     fn peek_next<'a>(&'a mut self) -> Option<&'a mut A> {
         match self.curs.resolve() {
-            None => self.list.peek_front_mut(),
+            None => self.list.front_mut(),
             Some(curs) => match curs.next {
                 None => None,
                 Some(ref mut node) => Some(&mut node.value),
@@ -574,14 +577,14 @@ mod tests {
         n.push_front(2);
         n.push_front(3);
         {
-            assert_eq!(n.peek_front().unwrap(), &3);
-            let x = n.peek_front_mut().unwrap();
+            assert_eq!(n.front().unwrap(), &3);
+            let x = n.front_mut().unwrap();
             assert_eq!(*x, 3);
             *x = 0;
         }
         {
-            assert_eq!(n.peek_back().unwrap(), &2);
-            let y = n.peek_back_mut().unwrap();
+            assert_eq!(n.back().unwrap(), &2);
+            let y = n.back_mut().unwrap();
             assert_eq!(*y, 2);
             *y = 1;
         }