pipecircuit 0.0.24

Correct. Robust. Fast. Portable. Pick four.
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
68
69
70
71
72
73
74
75
76
77
78
79
80

#![cfg(feature = "storage")]

use core::mem::MaybeUninit;
use pipecircuit::storage::warp_table::{
    CallerUniqueIndexStorage, ColumnLease, UniqueIndex, UniqueIndexInsertError,
    UniqueIndexInsertOutcome, UniqueIndexLookupOutcome, UniqueIndexRemoveOutcome,
    UniqueIndexReplaceOutcome,
};

#[global_allocator]
static ALLOCATOR: dhat::Alloc = dhat::Alloc;

#[test]
fn construction_full_refusal_and_churn_allocate_nothing() -> Result<(), &'static str> {
    let mut keys = [MaybeUninit::<u64>::uninit(); 17];
    let mut buckets = [0; 34];
    let _profiler = dhat::Profiler::builder().testing().build();
    let mut index = UniqueIndex::try_from_storage(
        17,
        CallerUniqueIndexStorage {
            keys: ColumnLease::new(&mut keys),
            buckets: &mut buckets,
        },
    )
    .map_err(|_| "construction")?;
    for key in 0..17 {
        let UniqueIndexInsertOutcome::Inserted { key: inserted, .. } = index
            .try_prepare_insert(key)
            .map_err(|_| "insert")?
            .commit();
        assert_eq!(inserted, key);
    }
    assert_eq!(
        index.try_prepare_insert(17).err(),
        Some(UniqueIndexInsertError::Full {
            key: 17,
            maximum_keys: 17
        })
    );
    for source in 0..256 {
        let row = match index.find(source).map_err(|_| "lookup")? {
            UniqueIndexLookupOutcome::Present { row, .. } => row,
            UniqueIndexLookupOutcome::Absent { .. } => return Err("missing key"),
        };
        let target = source.checked_add(17).ok_or("target")?;
        assert_eq!(
            index
                .try_prepare_replace(source, target, row)
                .map_err(|_| "replace")?
                .commit(),
            UniqueIndexReplaceOutcome::Replaced {
                source,
                target,
                row
            }
        );
        assert_eq!(
            index
                .try_prepare_remove(target)
                .map_err(|_| "remove")?
                .commit(),
            UniqueIndexRemoveOutcome::Removed { key: target, row }
        );
        assert_eq!(
            index
                .try_prepare_insert(target)
                .map_err(|_| "reinsert")?
                .commit(),
            UniqueIndexInsertOutcome::Inserted {
                key: target,
                row: 16
            }
        );
    }
    drop(index);
    let stats = dhat::HeapStats::get();
    assert_eq!(stats.total_blocks, 0);
    assert_eq!(stats.total_bytes, 0);
    Ok(())
}