Struct ArrayDeque

pub struct ArrayDeque<A: Array> { /* private fields */ }

A deque structure that uses an array as backing storage.

Example

use tinydeque::ArrayDeque;

// lots of people try to cut through the line at the DMV, and that's a dick move
// if I've ever seen one. Let's make a program to keep track
let mut dmv_line: ArrayDeque<[&'static str; 3]> = ArrayDeque::new();
dmv_line.push_back("John");
dmv_line.push_back("Thomas");
dmv_line.push_back("Larson");

// make sure the line isn't empty
assert!(!dmv_line.is_empty());
assert_eq!(dmv_line.len(), 3);

// if we push another item into the line, it will fail
assert!(dmv_line.try_push_back("Carson").is_err());

// NEXT!
assert_eq!(dmv_line.pop_front(), Some("John"));

// we have a VIP, front of the line!
dmv_line.push_front("J.J. Abrams");
assert_eq!(dmv_line.pop_front(), Some("J.J. Abrams"));

// why did J.J. Abrams get to cut in front of me in line?
// fuck this, I'm out of here
assert_eq!(dmv_line.pop_back(), Some("Larson"));

Implementations

impl<A: Array> ArrayDeque<A>

pub fn new() -> Self

Create a new ArrayDeque.

Example

let foobar: ArrayDeque<[i32; 5]> = ArrayDeque::new();

Examples found in repository

examples/interactive_test.rs (line 24)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn capacity() -> usize

The capacity of this ArrayDeque. This is the maximum number of elements that can be stored in this ArrayDeque.

Example

assert_eq!(ArrayDeque::<[&'static str; 8]>::capacity(), 8);

Examples found in repository

examples/interactive_test.rs (line 69)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn len(&self) -> usize

Get the length of this ArrayDeque.

Example

use tinydeque::ArrayDeque;

// we've been hired by the Crab Patrol to find and destroy some crabs
// they said we shouldn't use Rust to do this but let's do it anyways

/// Representative of a single crab.
#[derive(Default)]
struct Crab {
    diameter: u16,
    danger_level: u16,
}

let mut crab_hitlist: ArrayDeque<[Crab; 10]> = ArrayDeque::new();
for i in 1..=10 {
    crab_hitlist.push_back(Crab { diameter: i, danger_level: 100 / i }); // small crabs are more dangerous
}

assert_eq!(crab_hitlist.len(), 10);

Examples found in repository

examples/interactive_test.rs (line 70)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn is_empty(&self) -> bool

Tell whether this ArrayDeque is empty.

Example

let empty_deque: ArrayDeque<[(); 12]> = ArrayDeque::new();
assert!(empty_deque.is_empty());

Examples found in repository

examples/interactive_test.rs (line 73)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn is_full(&self) -> bool

Tell whether this ArrayDeque is full, or its entire capacity is filled with elements.

Example

let full_deque: ArrayDeque<[i64; 12]> = (0i64..12).into_iter().collect();
assert!(full_deque.is_full());

Examples found in repository

examples/interactive_test.rs (line 77)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn try_push_back(&mut self, element: A::Item) -> Result<(), A::Item>

Push an element onto the back of this ArrayDeque.

Errors

If this ArrayDeque is full, this function returns an Err with the rejected element.

Example

use tinydeque::ArrayDeque;

// we've been hired by the United Artists of America to manage their art gallery
// because they're starving artists, they don't have the money to afford good hardware
// thus we can only store 5 paintings at a time

/// Represents a painting.
#[derive(Default)]
struct Painting {
    name: &'static str,
    rating: u8,
}

let mut painting_list: ArrayDeque<[Painting; 10]> = ArrayDeque::new();
let mut i = 0;

// we have a lot of paintings named "The Jaguar" of questionable quality
while let Ok(()) = painting_list.try_push_back(Painting { name: "The Jaguar", rating: 3 }) { i += 1; }

assert_eq!(i, 10);

Examples found in repository

examples/interactive_test.rs (line 58)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn push_back(&mut self, element: A::Item)

Push an element onto the back of this ArrayDeque.

Panics

This function will panic if the ArrayDeque is full.

pub fn try_push_front(&mut self, element: A::Item) -> Result<(), A::Item>

Push an element onto the front of this ArrayDeque.

Errors

If this ArrayDeque is full, this function returns an Err with the rejected element.

Examples found in repository

examples/interactive_test.rs (line 63)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn push_front(&mut self, element: A::Item)

Push an element onto the front of this ArrayDeque.

Panics

This function will panic if the ArrayDeque is full.

pub fn pop_back(&mut self) -> Option<A::Item>

Pop an element from the back of this ArrayDeque.

Examples found in repository

examples/interactive_test.rs (line 67)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn pop_front(&mut self) -> Option<A::Item>

Pop an element from the front of this ArrayDeque.

Examples found in repository

examples/interactive_test.rs (line 68)

fn main() {
    let mut test_deque: ArrayDeque<[i32; 10]> = ArrayDeque::new();

    help();
    loop {
        print!("> ");
        io::stdout().flush().unwrap();
        let mut line = String::new();
        io::stdin().read_line(&mut line).unwrap();
        if line.is_empty() {
            continue;
        }
        let command = (
            line.remove(0),
            if !line.is_empty() {
                Some(line.remove(0))
            } else {
                None
            },
        );
        if line.chars().next() == Some(' ') {
            line.remove(0);
            line.pop();
        }
        let item = if line.len() > 0 {
            match line.parse::<i32>() {
                Ok(s) => s,
                Err(_) => 0,
            }
        } else {
            0i32
        };

        match command {
            ('p', Some('b')) => {
                if let Err(reject) = test_deque.try_push_back(item) {
                    println!("Unable to push element onto deque back: {}", reject);
                }
            }
            ('p', Some('f')) => {
                if let Err(reject) = test_deque.try_push_front(item) {
                    println!("Unable to push element onto deque front: {}", reject);
                }
            }
            ('o', Some('b')) => println!("{:?}", test_deque.pop_back()),
            ('o', Some('f')) => println!("{:?}", test_deque.pop_front()),
            ('c', _) => println!("Capacity: {}", ArrayDeque::<[i32; 10]>::capacity()),
            ('l', _) => println!("Length: {}", test_deque.len()),
            ('e', _) => println!(
                "Deque is{} empty",
                if test_deque.is_empty() { "" } else { " not" }
            ),
            ('f', _) => println!(
                "Deque is{} full",
                if test_deque.is_full() { "" } else { " not " }
            ),
            ('d', _) => println!("{:?}", &test_deque),
            ('h', _) => help(),
            ('q', _) => return,
            _ => println!("Unrecognized command"),
        }
    }
}

pub fn get(&self, index: usize) -> Option<&A::Item>

Get an element at the given index.

Example

use tinydeque::ArrayDeque;

let mut my_favorite_numbers = ArrayDeque::<[i32; 6]>::new();
my_favorite_numbers.push_back(5);
my_favorite_numbers.push_back(50);
my_favorite_numbers.push_back(33);
my_favorite_numbers.push_front(48);

assert_eq!(my_favorite_numbers.get(0), Some(&48));
assert_eq!(my_favorite_numbers.get(2), Some(&50));
assert_eq!(my_favorite_numbers.get(4), None);

pub fn get_mut(&mut self, index: usize) -> Option<&mut A::Item>

Get a mutable reference to an element at a given index.

pub fn is_contiguous(&self) -> bool

Tell whether or not this ArrayDeque is contiguous.

pub fn as_slices(&self) -> (&[A::Item], &[A::Item])

Get the contents of this ArrayDeque in the form of buffer slices.

pub fn as_mut_slices(&mut self) -> (&mut [A::Item], &mut [A::Item])

Get the contents of this ArrayDeque in the form of mutable buffer slices.

pub fn truncate(&mut self, len: usize)

Truncate this ArrayDeque to a certain size.

pub fn clear(&mut self)

Clear this ArrayDeque of all elements.

pub fn iter(&self) -> Iter<'_, A>

Create a new iterator.

pub fn append(&mut self, other: &mut Self) -> Result<(), ()>

Append another ArrayDeque onto the back of one.

Errors

If the ArrayDeque’s contents cannot fit into this one, the Err value is returned.

pub fn back(&self) -> Option<&A::Item>

Get the back item of this ArrayDeque.

pub fn back_mut(&mut self) -> Option<&mut A::Item>

Get a mutable reference to the back item of this ArrayDeque.

pub fn front(&self) -> Option<&A::Item>

Get the front item of this ArrayDeque.

pub fn front_mut(&mut self) -> Option<&mut A::Item>

Get a mutable reference to the front item of this ArrayDeque.

pub fn contains(&self, item: &A::Item) -> bool

where A::Item: PartialEq,

Tell whether or not this deque contains an element.

Trait Implementations

impl<A: Array> Clone for ArrayDeque<A>

where A::Item: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Array> Debug for ArrayDeque<A>

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

Formats the value using the given formatter.

impl<A: Array> Default for ArrayDeque<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Array> Extend<<A as Array>::Item> for ArrayDeque<A>

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

where T: IntoIterator<Item = A::Item>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A: Array> FromIterator<<A as Array>::Item> for ArrayDeque<A>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = A::Item>,

Creates a value from an iterator.