Struct collections::dlist::DListExperimental [-]  [+] [src]

pub struct DList<T> {
    // some fields omitted
}

A doubly-linked list.

Methods

impl<T> DList<T>

fn new() -> DList<T>

Creates an empty DList.

fn rotate_forward(&mut self)

Moves the last element to the front of the list.

If the list is empty, does nothing.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut dl = DList::new(); dl.push_back(1i); dl.push_back(2); dl.push_back(3); dl.rotate_forward(); for e in dl.iter() { println!("{}", e); // prints 3, then 1, then 2 } }
use std::collections::DList;

let mut dl = DList::new();
dl.push_back(1i);
dl.push_back(2);
dl.push_back(3);

dl.rotate_forward();

for e in dl.iter() {
    println!("{}", e); // prints 3, then 1, then 2
}

fn rotate_backward(&mut self)

Moves the first element to the back of the list.

If the list is empty, does nothing.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut dl = DList::new(); dl.push_back(1i); dl.push_back(2); dl.push_back(3); dl.rotate_backward(); for e in dl.iter() { println!("{}", e); // prints 2, then 3, then 1 } }
use std::collections::DList;

let mut dl = DList::new();
dl.push_back(1i);
dl.push_back(2);
dl.push_back(3);

dl.rotate_backward();

for e in dl.iter() {
    println!("{}", e); // prints 2, then 3, then 1
}

fn append(&mut self, other: DList<T>)

Adds all elements from other to the end of the list.

This operation should compute in O(1) time.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut a = DList::new(); let mut b = DList::new(); a.push_back(1i); a.push_back(2); b.push_back(3i); b.push_back(4); a.append(b); for e in a.iter() { println!("{}", e); // prints 1, then 2, then 3, then 4 } }
use std::collections::DList;

let mut a = DList::new();
let mut b = DList::new();
a.push_back(1i);
a.push_back(2);
b.push_back(3i);
b.push_back(4);

a.append(b);

for e in a.iter() {
    println!("{}", e); // prints 1, then 2, then 3, then 4
}

fn prepend(&mut self, other: DList<T>)

Adds all elements from other to the beginning of the list.

This operation should compute in O(1) time.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut a = DList::new(); let mut b = DList::new(); a.push_back(1i); a.push_back(2); b.push_back(3i); b.push_back(4); a.prepend(b); for e in a.iter() { println!("{}", e); // prints 3, then 4, then 1, then 2 } }
use std::collections::DList;

let mut a = DList::new();
let mut b = DList::new();
a.push_back(1i);
a.push_back(2);
b.push_back(3i);
b.push_back(4);

a.prepend(b);

for e in a.iter() {
    println!("{}", e); // prints 3, then 4, then 1, then 2
}

fn insert_when<F>(&mut self, elt: T, f: F) where F: FnMut(&T, &T) -> bool

Inserts elt before the first x in the list where f(x, elt) is true, or at the end.

This operation should compute in O(N) time.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut a: DList<int> = DList::new(); a.push_back(2i); a.push_back(4); a.push_back(7); a.push_back(8); // insert 11 before the first odd number in the list a.insert_when(11, |&e, _| e % 2 == 1); for e in a.iter() { println!("{}", e); // prints 2, then 4, then 11, then 7, then 8 } }
use std::collections::DList;

let mut a: DList<int> = DList::new();
a.push_back(2i);
a.push_back(4);
a.push_back(7);
a.push_back(8);

// insert 11 before the first odd number in the list
a.insert_when(11, |&e, _| e % 2 == 1);

for e in a.iter() {
    println!("{}", e); // prints 2, then 4, then 11, then 7, then 8
}

fn merge<F>(&mut self, other: DList<T>, f: F) where F: FnMut(&T, &T) -> bool

Merges other into this DList, using the function f.

Iterates both DLists with a from self and b from other, and put a in the result if f(a, b) is true, and otherwise b.

This operation should compute in O(max(N, M)) time.

fn iter<'a>(&'a self) -> Iter<'a, T>

Provides a forward iterator.

fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T>

Provides a forward iterator with mutable references.

fn into_iter(self) -> IntoIter<T>

Consumes the list into an iterator yielding elements by value.

fn is_empty(&self) -> bool

Returns true if the DList is empty.

This operation should compute in O(1) time.

fn len(&self) -> uint

Returns the length of the DList.

This operation should compute in O(1) time.

fn clear(&mut self)

Removes all elements from the DList.

This operation should compute in O(n) time.

fn front(&self) -> Option<&T>

Provides a reference to the front element, or None if the list is empty.

fn front_mut(&mut self) -> Option<&mut T>

Provides a mutable reference to the front element, or None if the list is empty.

fn back(&self) -> Option<&T>

Provides a reference to the back element, or None if the list is empty.

fn back_mut(&mut self) -> Option<&mut T>

Provides a mutable reference to the back element, or None if the list is empty.

fn push_front(&mut self, elt: T)

Adds an element first in the list.

This operation should compute in O(1) time.

fn pop_front(&mut self) -> Option<T>

Removes the first element and returns it, or None if the list is empty.

This operation should compute in O(1) time.

fn push(&mut self, elt: T)

Deprecated: Renamed to push_back.

fn push_back(&mut self, elt: T)

Appends an element to the back of a list

Examples

extern crate collections; fn main() { use std::collections::DList; let mut d = DList::new(); d.push_back(1i); d.push_back(3); assert_eq!(3, *d.back().unwrap()); }
use std::collections::DList;

let mut d = DList::new();
d.push_back(1i);
d.push_back(3);
assert_eq!(3, *d.back().unwrap());

fn pop(&mut self) -> Option<T>

Deprecated: Renamed to pop_back.

fn pop_back(&mut self) -> Option<T>

Removes the last element from a list and returns it, or None if it is empty.

Examples

extern crate collections; fn main() { use std::collections::DList; let mut d = DList::new(); assert_eq!(d.pop_back(), None); d.push_back(1i); d.push_back(3); assert_eq!(d.pop_back(), Some(3)); }
use std::collections::DList;

let mut d = DList::new();
assert_eq!(d.pop_back(), None);
d.push_back(1i);
d.push_back(3);
assert_eq!(d.pop_back(), Some(3));

impl<T: Ord> DList<T>

fn insert_ordered(&mut self, elt: T)

Inserts elt sorted in ascending order.

This operation should compute in O(N) time.

Trait Implementations

impl<T> Default for DList<T>

fn default() -> DList<T>

impl<T> Drop for DList<T>

fn drop(&mut self)

impl<A> FromIterator<A> for DList<A>

fn from_iter<T: Iterator<A>>(iterator: T) -> DList<A>

impl<A> Extend<A> for DList<A>

fn extend<T: Iterator<A>>(&mut self, iterator: T)

impl<A: PartialEq> PartialEq for DList<A>

fn eq(&self, other: &DList<A>) -> bool

fn ne(&self, other: &DList<A>) -> bool

impl<A: Eq> Eq for DList<A>

impl<A: PartialOrd> PartialOrd for DList<A>

fn partial_cmp(&self, other: &DList<A>) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl<A: Ord> Ord for DList<A>

fn cmp(&self, other: &DList<A>) -> Ordering

impl<A: Clone> Clone for DList<A>

fn clone(&self) -> DList<A>

fn clone_from(&mut self, source: &Self)

impl<A: Show> Show for DList<A>

fn fmt(&self, f: &mut Formatter) -> Result

impl<S: Writer, A: Hash<S>> Hash<S> for DList<A>

fn hash(&self, state: &mut S)