rust/src/libextra/dlist.rs

969 lines
33 KiB
Rust
Raw Normal View History

// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*!
A doubly-linked list. Supports O(1) head, tail, count, push, pop, etc.
# Safety note
Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
*/
use core::prelude::*;
use core::managed;
pub type DListLink<T> = Option<@mut DListNode<T>>;
#[allow(missing_doc)]
2013-01-24 17:40:46 -06:00
pub struct DListNode<T> {
data: T,
linked: bool, // for assertions
prev: DListLink<T>,
next: DListLink<T>,
2013-01-24 17:40:46 -06:00
}
#[allow(missing_doc)]
2013-01-24 17:40:46 -06:00
pub struct DList<T> {
size: uint,
hd: DListLink<T>,
tl: DListLink<T>,
2012-08-27 16:22:25 -05:00
}
impl<T> DListNode<T> {
fn assert_links(@mut self) {
2012-08-06 14:34:08 -05:00
match self.next {
2012-08-20 14:23:37 -05:00
Some(neighbour) => match neighbour.prev {
Some(me) => if !managed::mut_ptr_eq(self, me) {
fail!("Asymmetric next-link in dlist node.")
},
None => fail!("One-way next-link in dlist node.")
},
2012-08-20 14:23:37 -05:00
None => ()
}
2012-08-06 14:34:08 -05:00
match self.prev {
2012-08-20 14:23:37 -05:00
Some(neighbour) => match neighbour.next {
Some(me) => if !managed::mut_ptr_eq(me, self) {
fail!("Asymmetric prev-link in dlist node.")
},
None => fail!("One-way prev-link in dlist node.")
},
2012-08-20 14:23:37 -05:00
None => ()
}
}
}
impl<T> DListNode<T> {
/// Get the next node in the list, if there is one.
pub fn next_link(@mut self) -> DListLink<T> {
self.assert_links();
self.next
}
/// Get the next node in the list, failing if there isn't one.
pub fn next_node(@mut self) -> @mut DListNode<T> {
2012-08-06 14:34:08 -05:00
match self.next_link() {
2012-08-20 14:23:37 -05:00
Some(nobe) => nobe,
None => fail!("This dlist node has no next neighbour.")
}
}
/// Get the previous node in the list, if there is one.
pub fn prev_link(@mut self) -> DListLink<T> {
self.assert_links();
self.prev
}
/// Get the previous node in the list, failing if there isn't one.
pub fn prev_node(@mut self) -> @mut DListNode<T> {
2012-08-06 14:34:08 -05:00
match self.prev_link() {
2012-08-20 14:23:37 -05:00
Some(nobe) => nobe,
None => fail!("This dlist node has no previous neighbour.")
}
}
}
/// Creates a new dlist node with the given data.
pub fn new_dlist_node<T>(data: T) -> @mut DListNode<T> {
@mut DListNode { data: data, linked: false, prev: None, next: None }
}
/// Creates a new, empty dlist.
pub fn DList<T>() -> @mut DList<T> {
@mut DList { size: 0, hd: None, tl: None }
}
/// Creates a new dlist with a single element
pub fn from_elem<T>(data: T) -> @mut DList<T> {
2012-08-27 16:22:25 -05:00
let list = DList();
list.push(data);
list
}
/// Creates a new dlist from a vector of elements, maintaining the same order
pub fn from_vec<T:Copy>(vec: &[T]) -> @mut DList<T> {
do vec.iter().fold(DList()) |list,data| {
// Iterating left-to-right -- add newly to the tail.
list.push(copy *data);
list
}
}
/// Produce a list from a list of lists, leaving no elements behind in the
/// input. O(number of sub-lists).
pub fn concat<T>(lists: @mut DList<@mut DList<T>>) -> @mut DList<T> {
2012-08-27 16:22:25 -05:00
let result = DList();
while !lists.is_empty() {
result.append(lists.pop().get());
}
result
}
impl<T> DList<T> {
fn new_link(data: T) -> DListLink<T> {
Some(@mut DListNode {
data: data,
linked: true,
prev: None,
next: None
})
}
fn assert_mine(@mut self, nobe: @mut DListNode<T>) {
// These asserts could be stronger if we had node-root back-pointers,
// but those wouldn't allow for O(1) append.
if self.size == 0 {
fail!("This dlist is empty; that node can't be on it.")
}
if !nobe.linked { fail!("That node isn't linked to any dlist.") }
if !((nobe.prev.is_some()
|| managed::mut_ptr_eq(self.hd.expect("headless dlist?"),
2013-01-24 17:40:46 -06:00
nobe)) &&
(nobe.next.is_some()
|| managed::mut_ptr_eq(self.tl.expect("tailless dlist?"),
2013-01-24 17:40:46 -06:00
nobe))) {
fail!("That node isn't on this dlist.")
}
}
2013-03-04 21:36:15 -06:00
fn make_mine(&self, nobe: @mut DListNode<T>) {
if nobe.prev.is_some() || nobe.next.is_some() || nobe.linked {
fail!("Cannot insert node that's already on a dlist!")
}
nobe.linked = true;
}
// Link two nodes together. If either of them are 'none', also sets
// the head and/or tail pointers appropriately.
#[inline]
fn link(&mut self, before: DListLink<T>, after: DListLink<T>) {
2012-08-06 14:34:08 -05:00
match before {
2012-08-20 14:23:37 -05:00
Some(neighbour) => neighbour.next = after,
None => self.hd = after
}
2012-08-06 14:34:08 -05:00
match after {
2012-08-20 14:23:37 -05:00
Some(neighbour) => neighbour.prev = before,
None => self.tl = before
}
}
// Remove a node from the list.
fn unlink(@mut self, nobe: @mut DListNode<T>) {
self.assert_mine(nobe);
2013-03-28 20:39:09 -05:00
assert!(self.size > 0);
self.link(nobe.prev, nobe.next);
2012-08-20 14:23:37 -05:00
nobe.prev = None; // Release extraneous references.
nobe.next = None;
nobe.linked = false;
self.size -= 1;
}
fn add_head(@mut self, nobe: DListLink<T>) {
self.link(nobe, self.hd); // Might set tail too.
self.hd = nobe;
self.size += 1;
}
fn add_tail(@mut self, nobe: DListLink<T>) {
self.link(self.tl, nobe); // Might set head too.
self.tl = nobe;
self.size += 1;
}
fn insert_left(@mut self,
nobe: DListLink<T>,
neighbour: @mut DListNode<T>) {
self.assert_mine(neighbour);
2013-03-28 20:39:09 -05:00
assert!(self.size > 0);
self.link(neighbour.prev, nobe);
self.link(nobe, Some(neighbour));
self.size += 1;
}
fn insert_right(@mut self,
neighbour: @mut DListNode<T>,
nobe: DListLink<T>) {
self.assert_mine(neighbour);
2013-03-28 20:39:09 -05:00
assert!(self.size > 0);
self.link(nobe, neighbour.next);
self.link(Some(neighbour), nobe);
self.size += 1;
}
}
impl<T> DList<T> {
/**
* Iterates through the current contents.
*
* Attempts to access this dlist during iteration are allowed (to
* allow for e.g. breadth-first search with in-place enqueues), but
* removing the current node is forbidden.
*/
pub fn each(@mut self, f: &fn(v: &T) -> bool) -> bool {
let mut link = self.peek_n();
while link.is_some() {
let nobe = link.get();
assert!(nobe.linked);
{
let frozen_nobe = &*nobe;
if !f(&frozen_nobe.data) { return false; }
}
// Check (weakly) that the user didn't do a remove.
if self.size == 0 {
fail!("The dlist became empty during iteration??")
}
if !nobe.linked ||
(!((nobe.prev.is_some()
|| managed::mut_ptr_eq(self.hd.expect("headless dlist?"),
nobe))
&& (nobe.next.is_some()
|| managed::mut_ptr_eq(self.tl.expect("tailless dlist?"),
nobe)))) {
fail!("Removing a dlist node during iteration is forbidden!")
}
link = nobe.next_link();
}
return true;
}
/// Get the size of the list. O(1).
pub fn len(@mut self) -> uint { self.size }
/// Returns true if the list is empty. O(1).
pub fn is_empty(@mut self) -> bool { self.len() == 0 }
/// Add data to the head of the list. O(1).
pub fn push_head(@mut self, data: T) {
2013-01-24 17:40:46 -06:00
self.add_head(DList::new_link(data));
}
/**
* Add data to the head of the list, and get the new containing
* node. O(1).
*/
pub fn push_head_n(@mut self, data: T) -> @mut DListNode<T> {
2013-04-12 00:10:12 -05:00
let nobe = DList::new_link(data);
self.add_head(nobe);
2013-01-24 17:40:46 -06:00
nobe.get()
}
/// Add data to the tail of the list. O(1).
pub fn push(@mut self, data: T) {
2013-01-24 17:40:46 -06:00
self.add_tail(DList::new_link(data));
}
/**
* Add data to the tail of the list, and get the new containing
* node. O(1).
*/
pub fn push_n(@mut self, data: T) -> @mut DListNode<T> {
2013-04-12 00:10:12 -05:00
let nobe = DList::new_link(data);
self.add_tail(nobe);
2013-01-24 17:40:46 -06:00
nobe.get()
}
/**
* Insert data into the middle of the list, left of the given node.
* O(1).
*/
pub fn insert_before(@mut self, data: T, neighbour: @mut DListNode<T>) {
2013-01-24 17:40:46 -06:00
self.insert_left(DList::new_link(data), neighbour);
}
/**
* Insert an existing node in the middle of the list, left of the
* given node. O(1).
*/
pub fn insert_n_before(@mut self,
nobe: @mut DListNode<T>,
neighbour: @mut DListNode<T>) {
self.make_mine(nobe);
2012-08-20 14:23:37 -05:00
self.insert_left(Some(nobe), neighbour);
}
/**
* Insert data in the middle of the list, left of the given node,
* and get its containing node. O(1).
*/
pub fn insert_before_n(@mut self,
data: T,
neighbour: @mut DListNode<T>)
-> @mut DListNode<T> {
2013-04-12 00:10:12 -05:00
let nobe = DList::new_link(data);
self.insert_left(nobe, neighbour);
2013-01-24 17:40:46 -06:00
nobe.get()
}
/**
* Insert data into the middle of the list, right of the given node.
* O(1).
*/
pub fn insert_after(@mut self, data: T, neighbour: @mut DListNode<T>) {
2013-01-24 17:40:46 -06:00
self.insert_right(neighbour, DList::new_link(data));
}
/**
* Insert an existing node in the middle of the list, right of the
* given node. O(1).
*/
pub fn insert_n_after(@mut self,
nobe: @mut DListNode<T>,
neighbour: @mut DListNode<T>) {
self.make_mine(nobe);
2012-08-20 14:23:37 -05:00
self.insert_right(neighbour, Some(nobe));
}
/**
* Insert data in the middle of the list, right of the given node,
* and get its containing node. O(1).
*/
pub fn insert_after_n(@mut self,
data: T,
neighbour: @mut DListNode<T>)
-> @mut DListNode<T> {
2013-04-12 00:10:12 -05:00
let nobe = DList::new_link(data);
self.insert_right(neighbour, nobe);
2013-01-24 17:40:46 -06:00
nobe.get()
}
/// Remove a node from the head of the list. O(1).
pub fn pop_n(@mut self) -> DListLink<T> {
let hd = self.peek_n();
hd.map(|nobe| self.unlink(*nobe));
hd
}
/// Remove a node from the tail of the list. O(1).
pub fn pop_tail_n(@mut self) -> DListLink<T> {
let tl = self.peek_tail_n();
tl.map(|nobe| self.unlink(*nobe));
tl
}
/// Get the node at the list's head. O(1).
pub fn peek_n(@mut self) -> DListLink<T> { self.hd }
/// Get the node at the list's tail. O(1).
pub fn peek_tail_n(@mut self) -> DListLink<T> { self.tl }
/// Get the node at the list's head, failing if empty. O(1).
pub fn head_n(@mut self) -> @mut DListNode<T> {
2012-08-06 14:34:08 -05:00
match self.hd {
2012-08-20 14:23:37 -05:00
Some(nobe) => nobe,
None => fail!("Attempted to get the head of an empty dlist.")
}
}
/// Get the node at the list's tail, failing if empty. O(1).
pub fn tail_n(@mut self) -> @mut DListNode<T> {
2012-08-06 14:34:08 -05:00
match self.tl {
2012-08-20 14:23:37 -05:00
Some(nobe) => nobe,
None => fail!("Attempted to get the tail of an empty dlist.")
}
}
/// Remove a node from anywhere in the list. O(1).
pub fn remove(@mut self, nobe: @mut DListNode<T>) { self.unlink(nobe); }
/**
* Empty another list onto the end of this list, joining this list's tail
* to the other list's head. O(1).
*/
pub fn append(@mut self, them: @mut DList<T>) {
if managed::mut_ptr_eq(self, them) {
fail!("Cannot append a dlist to itself!")
}
if them.len() > 0 {
self.link(self.tl, them.hd);
self.tl = them.tl;
self.size += them.size;
them.size = 0;
2012-08-20 14:23:37 -05:00
them.hd = None;
them.tl = None;
}
}
/**
* Empty another list onto the start of this list, joining the other
* list's tail to this list's head. O(1).
*/
pub fn prepend(@mut self, them: @mut DList<T>) {
if managed::mut_ptr_eq(self, them) {
fail!("Cannot prepend a dlist to itself!")
}
if them.len() > 0 {
self.link(them.tl, self.hd);
self.hd = them.hd;
self.size += them.size;
them.size = 0;
2012-08-20 14:23:37 -05:00
them.hd = None;
them.tl = None;
}
}
/// Reverse the list's elements in place. O(n).
pub fn reverse(@mut self) {
do self.hd.while_some |nobe| {
let next_nobe = nobe.next;
self.remove(nobe);
self.make_mine(nobe);
2012-08-20 14:23:37 -05:00
self.add_head(Some(nobe));
next_nobe
}
}
/**
* Remove everything from the list. This is important because the cyclic
* links won't otherwise be automatically refcounted-collected. O(n).
*/
pub fn clear(@mut self) {
// Cute as it would be to simply detach the list and proclaim "O(1)!",
// the GC would still be a hidden O(n). Better to be honest about it.
while !self.is_empty() {
2012-07-25 23:23:42 -05:00
let _ = self.pop_n();
}
}
/// Iterate over nodes.
pub fn each_node(@mut self, f: &fn(@mut DListNode<T>) -> bool) -> bool {
2013-05-03 15:33:33 -05:00
let mut link = self.peek_n();
while link.is_some() {
let nobe = link.get();
if !f(nobe) { return false; }
link = nobe.next_link();
}
return true;
}
/// Check data structure integrity. O(n).
pub fn assert_consistent(@mut self) {
2013-01-24 17:40:46 -06:00
if self.hd.is_none() || self.tl.is_none() {
2013-03-28 20:39:09 -05:00
assert!(self.hd.is_none() && self.tl.is_none());
}
// iterate forwards
let mut count = 0;
let mut link = self.peek_n();
let mut rabbit = link;
2013-01-24 17:40:46 -06:00
while link.is_some() {
let nobe = link.get();
2013-03-28 20:39:09 -05:00
assert!(nobe.linked);
// check cycle
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
rabbit = rabbit.get().next;
2012-09-21 21:37:57 -05:00
}
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
rabbit = rabbit.get().next;
2012-09-21 21:37:57 -05:00
}
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
2013-03-28 20:39:09 -05:00
assert!(!managed::mut_ptr_eq(rabbit.get(), nobe));
}
// advance
link = nobe.next_link();
count += 1;
}
assert_eq!(count, self.len());
// iterate backwards - some of this is probably redundant.
link = self.peek_tail_n();
rabbit = link;
2013-01-24 17:40:46 -06:00
while link.is_some() {
let nobe = link.get();
2013-03-28 20:39:09 -05:00
assert!(nobe.linked);
// check cycle
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
rabbit = rabbit.get().prev;
2012-09-21 21:37:57 -05:00
}
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
rabbit = rabbit.get().prev;
2012-09-21 21:37:57 -05:00
}
2013-01-24 17:40:46 -06:00
if rabbit.is_some() {
2013-03-28 20:39:09 -05:00
assert!(!managed::mut_ptr_eq(rabbit.get(), nobe));
}
// advance
link = nobe.prev_link();
count -= 1;
}
assert_eq!(count, 0);
}
}
impl<T:Copy> DList<T> {
2012-07-25 23:23:42 -05:00
/// Remove data from the head of the list. O(1).
pub fn pop(@mut self) -> Option<T> {
self.pop_n().map(|nobe| copy nobe.data)
2013-01-24 17:40:46 -06:00
}
2012-07-25 23:23:42 -05:00
/// Remove data from the tail of the list. O(1).
pub fn pop_tail(@mut self) -> Option<T> {
self.pop_tail_n().map(|nobe| copy nobe.data)
2013-01-24 17:40:46 -06:00
}
/// Get data at the list's head. O(1).
pub fn peek(@mut self) -> Option<T> {
self.peek_n().map(|nobe| copy nobe.data)
2013-01-24 17:40:46 -06:00
}
/// Get data at the list's tail. O(1).
pub fn peek_tail(@mut self) -> Option<T> {
self.peek_tail_n().map (|nobe| copy nobe.data)
}
2013-01-24 17:40:46 -06:00
/// Get data at the list's head, failing if empty. O(1).
pub fn head(@mut self) -> T { copy self.head_n().data }
2013-01-24 17:40:46 -06:00
/// Get data at the list's tail, failing if empty. O(1).
pub fn tail(@mut self) -> T { copy self.tail_n().data }
}
#[cfg(test)]
mod tests {
use core::prelude::*;
use super::*;
#[test]
fn test_dlist_concat() {
2013-05-23 11:39:00 -05:00
let a = from_vec([1,2]);
let b = from_vec([3,4]);
let c = from_vec([5,6]);
let d = from_vec([7,8]);
let ab = from_vec([a,b]);
let cd = from_vec([c,d]);
let abcd = concat(concat(from_vec([ab,cd])));
abcd.assert_consistent(); assert_eq!(abcd.len(), 8);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 1);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 2);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 3);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 4);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 5);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 6);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 7);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 8);
2013-03-28 20:39:09 -05:00
abcd.assert_consistent(); assert!(abcd.is_empty());
}
#[test]
fn test_dlist_append() {
2013-05-23 11:39:00 -05:00
let a = from_vec([1,2,3]);
let b = from_vec([4,5,6]);
a.append(b);
assert_eq!(a.len(), 6);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 6);
2013-03-28 20:39:09 -05:00
a.assert_consistent(); assert!(a.is_empty());
}
#[test]
fn test_dlist_append_empty() {
2013-05-23 11:39:00 -05:00
let a = from_vec([1,2,3]);
2012-08-27 16:22:25 -05:00
let b = DList::<int>();
a.append(b);
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
2013-03-28 20:39:09 -05:00
a.assert_consistent(); assert!(a.is_empty());
}
#[test]
fn test_dlist_append_to_empty() {
2012-08-27 16:22:25 -05:00
let a = DList::<int>();
2013-05-23 11:39:00 -05:00
let b = from_vec([4,5,6]);
a.append(b);
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 6);
2013-03-28 20:39:09 -05:00
a.assert_consistent(); assert!(a.is_empty());
}
#[test]
fn test_dlist_append_two_empty() {
2012-08-27 16:22:25 -05:00
let a = DList::<int>();
let b = DList::<int>();
a.append(b);
assert_eq!(a.len(), 0);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent();
}
#[test]
#[ignore(cfg(windows))]
#[should_fail]
fn test_dlist_append_self() {
2012-08-27 16:22:25 -05:00
let a = DList::<int>();
a.append(a);
}
#[test]
#[ignore(cfg(windows))]
#[should_fail]
fn test_dlist_prepend_self() {
2012-08-27 16:22:25 -05:00
let a = DList::<int>();
a.prepend(a);
}
#[test]
fn test_dlist_prepend() {
2013-05-23 11:39:00 -05:00
let a = from_vec([1,2,3]);
let b = from_vec([4,5,6]);
b.prepend(a);
assert_eq!(a.len(), 0);
assert_eq!(b.len(), 6);
a.assert_consistent();
b.assert_consistent(); assert_eq!(b.pop().get(), 1);
b.assert_consistent(); assert_eq!(b.pop().get(), 2);
b.assert_consistent(); assert_eq!(b.pop().get(), 3);
b.assert_consistent(); assert_eq!(b.pop().get(), 4);
b.assert_consistent(); assert_eq!(b.pop().get(), 5);
b.assert_consistent(); assert_eq!(b.pop().get(), 6);
2013-03-28 20:39:09 -05:00
b.assert_consistent(); assert!(b.is_empty());
}
#[test]
fn test_dlist_reverse() {
2013-05-23 11:39:00 -05:00
let a = from_vec([5,4,3,2,1]);
a.reverse();
assert_eq!(a.len(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
2013-03-28 20:39:09 -05:00
a.assert_consistent(); assert!(a.is_empty());
}
#[test]
fn test_dlist_reverse_empty() {
2012-08-27 16:22:25 -05:00
let a = DList::<int>();
a.reverse();
assert_eq!(a.len(), 0);
a.assert_consistent();
}
#[test]
fn test_dlist_each_node() {
2013-05-23 11:39:00 -05:00
let a = from_vec([1,2,4,5]);
for a.each_node |nobe| {
if nobe.data > 3 {
a.insert_before(3, nobe);
}
}
assert_eq!(a.len(), 6);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
2013-03-28 20:39:09 -05:00
a.assert_consistent(); assert!(a.is_empty());
}
#[test]
fn test_dlist_clear() {
2013-05-23 11:39:00 -05:00
let a = from_vec([5,4,3,2,1]);
2012-07-25 23:23:42 -05:00
a.clear();
assert_eq!(a.len(), 0);
2012-07-25 23:23:42 -05:00
a.assert_consistent();
}
#[test]
fn test_dlist_is_empty() {
2012-08-27 16:22:25 -05:00
let empty = DList::<int>();
2013-05-23 11:39:00 -05:00
let full1 = from_vec([1,2,3]);
2013-03-28 20:39:09 -05:00
assert!(empty.is_empty());
assert!(!full1.is_empty());
}
#[test]
fn test_dlist_head_tail() {
2013-05-23 11:39:00 -05:00
let l = from_vec([1,2,3]);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
fn test_dlist_pop() {
2013-05-23 11:39:00 -05:00
let l = from_vec([1,2,3]);
assert_eq!(l.pop().get(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.head(), 2);
assert_eq!(l.pop().get(), 2);
assert_eq!(l.tail(), 3);
assert_eq!(l.head(), 3);
assert_eq!(l.pop().get(), 3);
2013-03-28 20:39:09 -05:00
assert!(l.is_empty());
assert!(l.pop().is_none());
}
#[test]
fn test_dlist_pop_tail() {
2013-05-23 11:39:00 -05:00
let l = from_vec([1,2,3]);
assert_eq!(l.pop_tail().get(), 3);
assert_eq!(l.tail(), 2);
assert_eq!(l.head(), 1);
assert_eq!(l.pop_tail().get(), 2);
assert_eq!(l.tail(), 1);
assert_eq!(l.head(), 1);
assert_eq!(l.pop_tail().get(), 1);
2013-03-28 20:39:09 -05:00
assert!(l.is_empty());
assert!(l.pop_tail().is_none());
}
#[test]
fn test_dlist_push() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.push(1);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 1);
l.push(2);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 2);
l.push(3);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
fn test_dlist_push_head() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.push_head(3);
assert_eq!(l.head(), 3);
assert_eq!(l.tail(), 3);
l.push_head(2);
assert_eq!(l.head(), 2);
assert_eq!(l.tail(), 3);
l.push_head(1);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
fn test_dlist_break_early() {
2013-05-23 11:39:00 -05:00
let l = from_vec([1,2,3,4,5]);
let mut x = 0;
for l.each |i| {
x += 1;
if (*i == 3) { break; }
}
assert_eq!(x, 3);
}
#[test]
fn test_dlist_remove_head() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 2);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_mid() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_tail() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_one_two() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); l.remove(two);
// and through and through, the vorpal blade went snicker-snack
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 3);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_one_three() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 2);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_two_three() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_remove_all() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); l.remove(one); // Twenty-three is number one!
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.peek().is_none());
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_insert_n_before() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = new_dlist_node(3);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_n_before(three, two);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_insert_n_after() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = new_dlist_node(3);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_n_after(three, one);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_insert_before_head() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_before(3, one);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 3);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test]
fn test_dlist_insert_after_tail() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_after(3, two);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
2013-03-28 20:39:09 -05:00
l.assert_consistent(); assert!(l.is_empty());
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_asymmetric_link() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
let _one = l.push_n(1);
2012-07-02 15:47:55 -05:00
let two = l.push_n(2);
2012-08-20 14:23:37 -05:00
two.prev = None;
2012-07-02 15:47:55 -05:00
l.assert_consistent();
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_cyclic_list() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
2012-07-02 15:47:55 -05:00
let one = l.push_n(1);
let _two = l.push_n(2);
let three = l.push_n(3);
2012-08-20 14:23:37 -05:00
three.next = Some(one);
one.prev = Some(three);
2012-07-02 15:47:55 -05:00
l.assert_consistent();
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_headless() {
2012-08-27 16:22:25 -05:00
DList::<int>().head();
2012-07-02 15:47:55 -05:00
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_insert_already_present_before() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
2012-07-02 15:47:55 -05:00
let one = l.push_n(1);
let two = l.push_n(2);
l.insert_n_before(two, one);
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_insert_already_present_after() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
2012-07-02 15:47:55 -05:00
let one = l.push_n(1);
let two = l.push_n(2);
l.insert_n_after(one, two);
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_insert_before_orphan() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
let one = new_dlist_node(1);
let two = new_dlist_node(2);
2012-07-02 15:47:55 -05:00
l.insert_n_before(one, two);
}
#[test] #[should_fail] #[ignore(cfg(windows))]
fn test_dlist_insert_after_orphan() {
2012-08-27 16:22:25 -05:00
let l = DList::<int>();
let one = new_dlist_node(1);
let two = new_dlist_node(2);
2012-07-02 15:47:55 -05:00
l.insert_n_after(two, one);
}
}