orx-fixed-vec 3.23.0

An efficient fixed capacity vector with pinned element guarantees.
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use orx_fixed_vec::*;

#[test]
fn reserve() {
    let vec = FixedVec::<String>::new(42);

    let mut con_vec = vec.into_concurrent();

    unsafe { con_vec.get_ptr_mut(0).write("first".to_string()) };

    assert_eq!(con_vec.capacity(), 42);
    assert_eq!(con_vec.max_capacity(), 42);

    unsafe { con_vec.reserve_maximum_concurrent_capacity(0, 74) };
    let new_capacity = con_vec.capacity();
    assert!(new_capacity >= 74);
    assert_eq!(con_vec.max_capacity(), new_capacity);

    let vec = unsafe { con_vec.into_inner(1) };

    assert_eq!(vec.len(), 1);
    assert_eq!(vec.capacity(), new_capacity);
    assert_eq!(&vec[0], &"first".to_string());
}

#[test]
fn into_concurrent_fill_with() {
    let vec = FixedVec::<String>::new(42);
    let con_vec = vec.into_concurrent_filled_with(|| "x".to_string());
    let vec = unsafe { con_vec.into_inner(42) };
    assert_eq!(vec, (0..42).map(|_| "x".to_string()).collect::<Vec<_>>());

    let mut vec = FixedVec::<String>::new(42);
    vec.push("y".to_string());
    let con_vec = vec.into_concurrent_filled_with(|| "x".to_string());
    let vec = unsafe { con_vec.into_inner(42) };
    assert_eq!(&vec[0], &"y".to_string());
    assert_eq!(
        vec[1..],
        (1..42).map(|_| "x".to_string()).collect::<Vec<_>>()
    );
}

#[test]
fn reserve_fill_with() {
    let vec = FixedVec::<String>::new(42);

    let mut con_vec = vec.into_concurrent_filled_with(|| "x".to_string());

    unsafe { con_vec.reserve_maximum_concurrent_capacity_fill_with(42, 74, || "y".to_string()) };
    let new_capacity = con_vec.capacity();
    assert!(new_capacity >= 74);
    assert_eq!(con_vec.max_capacity(), new_capacity);

    let vec = unsafe { con_vec.into_inner(new_capacity) };

    assert_eq!(
        vec[0..42],
        (0..42).map(|_| "x".to_string()).collect::<Vec<_>>()
    );
    assert_eq!(
        vec[42..],
        (42..new_capacity)
            .map(|_| "y".to_string())
            .collect::<Vec<_>>()
    );
}