Struct std::collections::DListStable [-]  [+] [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 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

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 iter(&self) -> Iter<T>

Provides a forward iterator.

fn iter_mut(&mut self) -> IterMut<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) -> usize

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_back(&mut self, elt: T)

Appends an element to the back of a list

Examples

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_back(&mut self) -> Option<T>

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

Examples

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));

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>(iterator: T) -> DList<A>

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

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

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

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

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

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

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

fn assert_receiver_is_total_eq(&self)

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

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

fn lt(&self, &DList<A>) -> bool

fn le(&self, &DList<A>) -> bool

fn gt(&self, &DList<A>) -> bool

fn ge(&self, &DList<A>) -> 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, &DList<A>)

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

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

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

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