inplace_it 0.3.6

Place small arrays on the stack with a low-cost!
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use std::cell::Cell;
use inplace_it::*;
use std::mem::MaybeUninit;

struct DropCounter {
    count: Cell<usize>,
}

impl DropCounter {
    fn with_current<F: FnOnce(&DropCounter) -> R, R>(f: F) -> R {
        thread_local!(
            static COUNTER: DropCounter = DropCounter {count: Cell::new(0)};
        );
        COUNTER.with(f)
    }

    #[inline]
    fn get() -> usize {
        DropCounter::with_current(|c| c.count.get())
    }

    #[inline]
    fn inc() {
        DropCounter::with_current(|c| c.count.set(c.count.get() + 1));
    }

    #[inline]
    fn clear() {
        DropCounter::with_current(|c| c.count.set(0));
    }
}

struct DropCounterTrigger(u8 /* One byte to avoid zero-sized types optimizations */);

impl DropCounterTrigger {
    fn new() -> Self {
        Self(228)
    }
}

impl Drop for DropCounterTrigger {
    #[inline]
    fn drop(&mut self) {
        DropCounter::inc();
    }
}

#[test]
fn maybe_uninit_works_as_expected() {
    DropCounter::clear();
    drop(MaybeUninit::<DropCounterTrigger>::uninit());
    assert_eq!(DropCounter::get(), 0);
    DropCounter::clear();
    drop(MaybeUninit::<DropCounterTrigger>::new(DropCounterTrigger::new()));
    assert_eq!(DropCounter::get(), 0);
    DropCounter::clear();
    let mut memory = MaybeUninit::<DropCounterTrigger>::new(DropCounterTrigger::new());
    unsafe { core::ptr::drop_in_place(memory.as_mut_ptr()); }
    drop(memory);
    assert_eq!(DropCounter::get(), 1);
}

#[test]
fn inplace_array_should_correctly_drop_values() {
    for i in (0..4096).step_by(8) {
        DropCounter::clear();
        try_inplace_array(i, |guard: UninitializedSliceMemoryGuard<DropCounterTrigger>| {
            assert!(guard.len() >= i);
        }).map_err(|_| format!("Cannot inplace array of {} size", i)).unwrap();
        assert_eq!(DropCounter::get(), 0);
        DropCounter::clear();
        let len = try_inplace_array(i, |guard| {
            let len = guard.len();
            guard.init(|_| DropCounterTrigger::new());
            len
        }).map_err(|_| format!("Cannot inplace array of {} size", i)).unwrap();
        assert_eq!(DropCounter::get(), len);
        DropCounter::clear();
        try_inplace_array(i, |guard| {
            let guard = guard.slice(..i);
            assert_eq!(guard.len(), i);
            guard.init(|_| DropCounterTrigger::new());
        }).map_err(|_| format!("Cannot inplace array of {} size", i)).unwrap();
        assert_eq!(DropCounter::get(), i);
    }
}

#[test]
fn alloc_array_should_correctly_drop_values() {
    for i in (0..4096).step_by(8) {
        DropCounter::clear();
        alloc_array(i, |_guard: UninitializedSliceMemoryGuard<DropCounterTrigger>| {});
        assert_eq!(DropCounter::get(), 0);
        DropCounter::clear();
        alloc_array(i, |guard| {
            guard.init(|_| DropCounterTrigger::new());
        });
        assert_eq!(DropCounter::get(), i);
    }
}