static-alloc 0.1.0

Replacements for `Box`, `Rc`, `Vec`, .. without `alloc`
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use core::mem;
use static_alloc::{rc, Slab};

#[test]
fn create() {
    let memory: Slab<[u8; 1024]> = Slab::uninit();

    let rc = memory.rc(0usize).unwrap();
    assert_eq!(rc::Rc::strong_count(&rc), 1);
    assert_eq!(rc::Rc::weak_count(&rc), 1);

    assert_eq!(rc.wrapping_add(1), 1);
    assert_eq!(*rc.as_ref(), 0);
}

#[test]
#[should_panic]
fn failed_memory_layout() {
    let mut memory: mem::MaybeUninit<()> = mem::MaybeUninit::uninit();
    rc::Rc::new(0usize, (&mut memory).into());
}

#[test]
fn reference_juggling() {
    #[derive(Debug)]
    struct HotPotato(usize);

    impl Drop for HotPotato {
        fn drop(&mut self) {
            panic!("dropped!");
        }
    }


    let memory: Slab<[u8; 1024]> = Slab::uninit();
    let alloc = memory.get_layout(rc::Rc::<HotPotato>::layout()).unwrap();
    let ptr = alloc.uninit.as_non_null();
    let mut foo = rc::Rc::new(HotPotato(0), alloc.uninit);

    rc::Rc::get_mut(&mut foo).unwrap().0 = 4;
    // Create a second Rc
    let foo2 = rc::Rc::clone(&foo);
    assert!(rc::Rc::get_mut(&mut foo).is_none());

    // Drop the second, now unique again.
    drop(foo2);
    assert!(rc::Rc::get_mut(&mut foo).is_some());

    // A weak pointer will also not allow a reference.
    let weak = rc::Rc::downgrade(&foo);
    assert!(rc::Rc::get_mut(&mut foo).is_none());
    drop(weak);

    let (val, weak) = rc::Rc::try_unwrap(foo).ok().unwrap();
    assert_eq!(rc::Weak::strong_count(&weak), 0);
    assert_eq!(rc::Weak::weak_count(&weak), 1);

    let mem = rc::Weak::try_unwrap(weak).ok().unwrap();
    assert_eq!(ptr, mem.as_non_null());

    mem::forget(val);
}

#[test]
fn raw_and_back() {
    let memory: Slab<[u8; 1024]> = Slab::uninit();

    let rc = memory.rc(0usize).unwrap();
    assert_eq!(rc::Rc::strong_count(&rc), 1);
    assert_eq!(rc::Rc::weak_count(&rc), 1);

    let raw = rc::Rc::into_raw(rc).ok().unwrap();
    let ptr_to_val = raw.as_non_null();

    let mut rc = unsafe { rc::Rc::from_raw(raw) };
    assert_eq!(rc::Rc::get_mut(&mut rc).unwrap() as *mut _, ptr_to_val.as_ptr());
}

#[test]
fn downgrade_upgrade() {
    let memory: Slab<[u8; 1024]> = Slab::uninit();

    let rc = memory.rc(0usize).unwrap();
    assert_eq!(rc::Rc::strong_count(&rc), 1);
    assert_eq!(rc::Rc::weak_count(&rc), 1);

    let weak = rc::Rc::downgrade(&rc);
    let rc2 = weak.upgrade().unwrap();

    assert_eq!(rc::Rc::strong_count(&rc), 2);
    assert_eq!(rc::Rc::weak_count(&rc), 2);
    drop(weak);

    drop(rc);
    let (_, weak) = rc::Rc::try_unwrap(rc2).ok().unwrap();
    assert_eq!(weak.strong_count(), 0);
    assert_eq!(weak.weak_count(), 1);

    assert!(weak.upgrade().is_none());
}

#[test]
fn compares() {
    let memory: Slab<[u8; 1024]> = Slab::uninit();

    let zero = memory.rc(0usize).unwrap();
    let one = memory.rc(1usize).unwrap();

    assert_eq!(zero, zero);
    assert_eq!(one, one);
    assert!(!(zero != zero));
    assert_ne!(zero, one);

    assert!(zero < one);
    assert!(zero <= one);
    assert!(one > zero);
    assert!(one >= zero);
}

#[test]
fn hashing() {
    use std::collections::HashMap;
    const KEY: usize = 0xdeadbeef;
    const VAL: &str = "mapped";
    let memory: Slab<[u8; 1024]> = Slab::uninit();

    let value = memory.rc(KEY).unwrap();
    let map = Some((value, VAL))
        .into_iter()
        .collect::<HashMap<_, _>>();

    assert_eq!(map.get(&KEY).cloned(), Some(VAL));
}