# multi_stack_queue

A crate for stack-allocated fixed-length multiqueues. A multiqueue is an array of a given number of queues, each able to be accessed independently.

Based on an original idea from [Pollux3737](https://github.com/Pollux3737).

# Usage

The generic definition is the following :

```rust
MultiStackQueue<T, const N: usize, const M: usize>
```

With :

* `T` - type contained in the queues
* `N` - length of each queue
* `M` - number of queues

# Example usecases

* When writing a simple micro-kernel, the scheduler may need some sort of multiple Round-Robins.
Having it allocated on the stack removes the need for a heap allocator, which can be useful
when working on this kind of ressource-limited target.

# Examples

```rust
use multi_stack_queue::MultiStackQueue;

#[derive(Debug, PartialEq, Eq)]
struct TestStruct {
    a: usize,
    b: bool,   
}

let mut msq: MultiStackQueue<TestStruct, 16, 8> = MultiStackQueue::new();
let value = TestStruct { a: 42, b: false };

msq.push(7, value).unwrap();

assert_eq!(msq.pop(7).unwrap(), value);
```

# Roadmap

[X] Using arrays of `Option<T>` requires that `T` implements the `Copy` trait, which may not be the case. A different approach is to use default values instead of `Option::None` to initialize the arrays. This way, `T` must need not implement `Copy` but `Default`, which may be beneficial in some usecases. Another idea would be to make use of the `MaybeUnInit` type.
[X] Add options in the generic definition of `MultiStackQueue` to enable the user to specify the procedure in case of a `push` on a full queue or a `pop` on an empty queue. For instance, one could wish trying to push an element to a full queue would simply push it to the following queue (and same thing when trying to `pop` an element). This would add a sort of "spill mechanism"