rc_event_queue 0.4.3

VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue.
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

use crate::dynamic_array::DynamicArray;
use itertools::assert_equal;
use std::cell::RefCell;

struct Header<F: FnMut(u8)>{
    i : u8,
    on_destroy : F
}
impl<F: FnMut(u8)> Drop for Header<F>{
    fn drop(&mut self) {
        (self.on_destroy)(self.i);
    }
}

struct Data<F: FnMut(usize)>{
    i : usize,
    on_destroy : F
}

impl<F: FnMut(usize)> Drop for Data<F>{
    fn drop(&mut self) {
        (self.on_destroy)(self.i);
    }
}


#[test]
fn uninit_test(){
    let data_destruct_order = RefCell::new(Vec::new());
    let on_destroy = |i:usize|{
        data_destruct_order.borrow_mut().push(i);
    };

    let header_destruct_counter = RefCell::new(0);
    let on_header_destroy = |_|{
        *header_destruct_counter.borrow_mut() += 1;
    };

    let fla = unsafe {
        &mut *DynamicArray::<Header<_>, Data<_>>::construct_uninit(
            Header { i: 100, on_destroy: on_header_destroy },
            8
        )
    };

    unsafe { fla.write_at(1, Data { i: 800, on_destroy }); }

    let array = fla.slice_mut();
    assert_eq!(array.len(), 8);
    assert_eq!(array[1].i, 800);
    assert_eq!(fla.header.i, 100);

    assert_eq!(*header_destruct_counter.borrow(), 0);
    assert!(data_destruct_order.borrow().is_empty());
    unsafe{ DynamicArray::destruct_uninit(fla); }
    assert!(data_destruct_order.borrow().is_empty());
    assert_eq!(*header_destruct_counter.borrow(), 1);
}

#[test]
fn default_test(){
    let data_destruct_order = RefCell::new(Vec::new());
    let on_destroy = |i:usize|{
        data_destruct_order.borrow_mut().push(i);
    };

    let header_destruct_counter = RefCell::new(0);
    let on_header_destroy = |_|{
        *header_destruct_counter.borrow_mut() += 1;
    };


    let fla = unsafe{
        &mut *DynamicArray::<Header<_>, Data<_>>::construct(
                Header { i: 100, on_destroy: on_header_destroy },
                Data { i: 0, on_destroy },
                4
            )
    };

    assert!(data_destruct_order.borrow().is_empty());
    {
        let array = fla.slice_mut();
        array[1] = Data{i : 800, on_destroy};
    }
    assert_equal(&*data_destruct_order.borrow(), &[0 as usize]);
    data_destruct_order.borrow_mut().clear();

    assert_eq!(fla.header.i, 100);
    assert_equal(fla.slice().iter().map(|data|data.i), [0, 800, 0, 0]);

    assert_eq!(*header_destruct_counter.borrow(), 0);
    unsafe{ DynamicArray::destruct(fla); }
    assert_equal(&*data_destruct_order.borrow(), &[0,800,0,0 as usize]);
    assert_eq!(*header_destruct_counter.borrow(), 1);
}

/*#[repr(transparent)]
struct Node(DynamicArray<Header, usize>);

impl Node{
    pub fn construct()-> &'static mut Self {
        let base = DynamicArray::<Header, usize>::construct(
            Header { i: 20 },
            0,
            10
        );
        unsafe { &mut *(base as *mut _ as *mut Self) }
    }

    pub unsafe fn destruct(this: *mut Self){
        DynamicArray::<Header, usize>::destruct(
            this as *mut DynamicArray<Header, usize>
        );
    }
}*/