arraydeque

A circular buffer with fixed capacity. Requires Rust 1.12+.

This crate is inspired by [bluss/arrayvec]

Feature Flags

The arraydeque crate has the following cargo feature flags:

• std

  • Optional, enabled by default
  • Requires Rust 1.6 to disable
  • Use libstd

• use_union

  • Optional
  • Requires Rust nightly channel
  • Use the unstable feature untagged unions for the internal implementation, which has reduced space overhead

• use_generic_array

  • Optional
  • Requires Rust stable channel
  • Depend on generic-array and allow using it just like a fixed size array for ArrayVec storage.

Usage

First, add the following to your Cargo.toml:

toml [dependencies] arraydeque = "0.1.2"

Next, add this to your crate root:

rust extern crate arraydeque;

Currently arraydeque by default links to the standard library, but if you would instead like to use arraydeque in a #![no_std] situation or crate you can request this via:

toml [dependencies] arraydeque = { version = "0.1.2", default-features = false }

Example

Push & Pop

```rust extern crate arraydeque;

use arraydeque::ArrayDeque;

fn main() { let mut vector: ArrayDeque<[; 8]> = ArrayDeque::new(); asserteq!(vector.capacity(), 7); assert_eq!(vector.len(), 0);

vector.push_back(1);
vector.push_back(2);
assert_eq!(vector.len(), 2);

assert_eq!(vector.pop_front(), Some(1));
assert_eq!(vector.pop_front(), Some(2));
assert_eq!(vector.pop_front(), None);

} ```

Insert & Remove

```rust use arraydeque::ArrayDeque;

let mut vector: ArrayDeque<[_; 8]> = ArrayDeque::new();

vector.pushback(11); vector.pushback(13); vector.insert(1, 12); vector.remove(0);

asserteq!(vector[0], 12); asserteq!(vector[1], 13); ```

Append & Extend

```rust use arraydeque::ArrayDeque;

let mut vector: ArrayDeque<[; 8]> = ArrayDeque::new(); let mut vector2: ArrayDeque<[; 8]> = ArrayDeque::new();

vector.extend(0..5); vector2.extend(5..7);

asserteq!(format!("{:?}", vector), "[0, 1, 2, 3, 4]"); asserteq!(format!("{:?}", vector2), "[5, 6]");

vector.append(&mut vector2);

asserteq!(format!("{:?}", vector), "[0, 1, 2, 3, 4, 5, 6]"); asserteq!(format!("{:?}", vector2), "[]"); ```

Iterator

```rust use arraydeque::ArrayDeque;

let mut vector: ArrayDeque<[_; 8]> = ArrayDeque::new();

vector.extend(0..5);

let iters: Vec<_> = vector.intoiter().collect(); asserteq!(iters, vec![0, 1, 2, 3, 4]); ```

From Iterator

```rust use arraydeque::ArrayDeque;

let vector: ArrayDeque<[; 8]>; let vector2: ArrayDeque<[; 8]>;

vector = vec![0, 1, 2, 3, 4].into_iter().collect();

vector2 = (0..5).into_iter().collect();

assert_eq!(vector, vector2); ```

Generic Array

toml [dependencies.arraydeque] version = "0.1.2" features = ["use_generic_array"] ```rust

[macro_use]

extern crate generic_array; extern crate arraydeque;

use genericarray::GenericArray; use genericarray::typenum::U41;

use arraydeque::ArrayDeque;

fn main() { let mut vec: ArrayDeque> = ArrayDeque::new();

assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 40);

vec.extend(0..20);

assert_eq!(vec.len(), 20);
assert_eq!(vec.into_iter().take(5).collect::<Vec<_>>(), vec![0, 1, 2, 3, 4]);

} ```

Contribution

All kinds of contribution are welcomed.

• Issus. Feel free to open an issue when you find typos, bugs, or have any question.
• Pull requests. New collection, better implementation, more tests, more documents and typo fixes are all welcomed.

License

Licensed under MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)