orx-fixed-vec 0.1.0

`FixedVec` implements `PinnedVec`: it preserves the memory locations of its elements and can be used to create an ImpVec allowing to push to the vector with an immutable reference. `FixedVec` allows operations with same complexity and speed of `std::vec::Vec` with the drawback that it cannot exceed its preset capacity.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# orx-fixed-vec


`FixedVec` implements [`PinnedVec`](https://crates.io/crates/orx-pinned-vec); therefore,

* it preserves the memory locations of already pushed elements.

This feature eliminates a specific set of errors leading to undefined behavior,
and hence, allows to work with a more flexible borrow checker.

Furthermore, it can be used as the underlying pinned vector of an
[`ImpVec`](https://crates.io/crates/orx-imp-vec), which adds the additional feature
to push to the vector with an immutable reference.

Unlike, another pinned vector implementation [`SplitVec`](https://crates.io/crates/orx-split-vec),
`FixedVec` allows operations with same complexity and speed of `std::vec::Vec`.

Its drawback, on the other hand, is that:

* it has a hard limit on its capacity,
* it will panic if the caller attempts to extend the vector beyond this limit.

```rust
use orx_fixed_vec::prelude::*;

let fixed_capacity = 42;
let mut vec = FixedVec::new(fixed_capacity);
assert_eq!(fixed_capacity, vec.capacity());

let mut initial_addresses = vec![];
for i in 0..fixed_capacity {
    vec.push(i);
    initial_addresses.push(vec.get(i).unwrap() as *const usize);
}

assert_eq!(fixed_capacity, vec.len());
assert_eq!(0, vec.room());
assert!(vec.is_full());

// addresses of already pushed elements stay intact
let final_addresses: Vec<_> = (0..fixed_capacity)
    .map(|i| vec.get(i).unwrap() as *const usize)
    .collect();
assert_eq!(initial_addresses, final_addresses);

// the next push when `vec.is_full()` panics!
// vec.push(42);
```