Crate trait_based_collection

source · [−]
Expand description

A collection of data structures that implement the Collection trait, allowing for a common interface for all the data structures in this crate. This crate is intended to be a proof of concept a common interface for all the data structures in Rust. Not all the data structures are implemented in this crate, but the ones that are implemented are:

  • Queue: A FIFO data structure based on linked nodes.
  • Deque: A FIFO and LIFO data structure based on linked nodes.
  • CircularDeque: A FIFO and LIFO data structure based on a circular array.
  • Stack: A LIFO data structure based on a linked nodes.
  • ArrayStack: A LIFO data structure based on a fixed size array.
  • BinaryHeap: A PriorityQueue data structure based on a binary heap.

The crate also contains the following traits:

  • Collection: A trait that defines the common interface for all the data structures in this crate.
  • FixedSizeCollection: A trait that defines the common interface for all the data structures in this crate that have a fixed size.
  • Iterators: A trait that defines the common interface for all the iterators in this crate.
  • DequeCollection: A trait that defines the common interface for all the data structures in this crate that are both FIFO and LIFO.

The crate also contains the following macros for easily creating data structures:

The crate also contain extra modules for creating new data structures and for creating macros that can be used to add functionality to the data structures in this crate. For more information about these modules, see the documentation of macros.

Example

use trait_based_collection::{import, Deque};
import!();

let mut deque = deque![1, 2, 3];

for i in 4..=10 {
   deque.add(i);
}

for i in 1..=10 {
   assert_eq!(deque.remove(), Some(i));
}

Re-exports

pub use self::collection::Collection;
pub use self::collection::ExpansionMode;
pub use self::collection::FixedSizeCollection;
pub use self::collection::Iterators;
pub use self::priority_queue::BinaryHeap;
pub use self::queue::CircularDeque;
pub use self::queue::Deque;
pub use self::queue::DequeCollection;
pub use self::queue::Queue;
pub use self::stack::ArrayStack;
pub use self::stack::Stack;

Modules

collection
Traits, helpers, and type definitions for the collection framework.
macros
A collection of all the procedural macros used in this crate. This macros can be divided into two categories:
prelude
A module that contains all the traits that are used in this crate. This module is meant to be used as a total import using the prelude::* syntax. The module also contains a macro that creates the prelude for this crate allowing to also import the macros in this crate.
priority_queue
A collection of different implementations of priority queues. The priority queue is a data structure that allows you to insert elements into it and then retrieve them in order of priority. The priority is determined through a comparator function that is passed to the priority queue.
queue
A collection of different implementations of a queue based on the FIFO principle. There some structs that implement the DequeCollection trait, which allows them to be used as both LIFO and FIFO queues.
stack
A collection of different implementations of a stack based on the LIFO principle.

Macros

array_stack
Creates a ArrayStack containing the arguments.
binary_heap
Creates a BinaryHeap containing the arguments.
circular_deque
Creates a CircularDeque containing the arguments.
deque
Creates a Deque containing the arguments.
import
Creates the prelude for this crate. This macro is meant to a substitute for the use trait_based_collection::prelude::* statement if the macros in this crate are also needed.
queue
Creates a Queue containing the arguments.
stack
Creates a Stack containing the arguments.