refpool 0.4.3

Efficient memory pool with reference counting
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use std::mem::MaybeUninit;

use crate::{
    box_handle::PoolBox, counter::Counter, pointer::Pointer, pool::Pool, ref_handle::PoolRef,
    types::ElementPointer,
};

pub(crate) unsafe fn assume_init<A>(maybe_boxed: Box<MaybeUninit<A>>) -> Box<A> {
    Box::from_raw(Box::into_raw(maybe_boxed).cast())
    // TODO: Change this to `maybe_boxed.assume_init()` when the `new_uninit`
    // feature stabilises.
}

pub(crate) unsafe fn data_ptr<A>(this: &mut MaybeUninit<RefBox<A>>) -> &mut MaybeUninit<A> {
    (*this.as_mut_ptr())
        .value_as_mut_ptr()
        .cast::<MaybeUninit<A>>()
        .as_mut()
        .unwrap()
}

#[repr(C)]
pub(crate) struct RefBox<A> {
    pub(crate) value: A,
    pub(crate) count: usize,
    pub(crate) pool: Pool<A>,
}

impl<A> RefBox<A> {
    pub(crate) fn into_ref(mut self: Box<Self>) -> PoolRef<A> {
        let ref_handle = self.new_ref();
        Box::leak(self);
        ref_handle
    }

    pub(crate) fn into_box(mut self: Box<Self>) -> PoolBox<A> {
        let box_handle = self.new_box();
        Box::leak(self);
        box_handle
    }

    pub(crate) fn new_ref(&mut self) -> PoolRef<A> {
        self.inc();
        PoolRef {
            handle: ElementPointer::wrap(self),
        }
    }

    pub(crate) fn new_box(&mut self) -> PoolBox<A> {
        self.inc();
        PoolBox {
            handle: ElementPointer::wrap(self),
        }
    }

    pub(crate) fn return_to_pool(self: Box<Self>) {
        if !self.pool.is_full() {
            let pool = self.pool.clone();
            let ptr = Box::into_raw(self);
            unsafe {
                ptr.drop_in_place();
                pool.push(ElementPointer::wrap(ptr));
            };
        }
    }

    pub(crate) fn value_as_ref(&self) -> &A {
        &self.value
    }

    pub(crate) fn value_as_mut(&mut self) -> &mut A {
        &mut self.value
    }

    pub(crate) unsafe fn value_as_mut_ptr(&mut self) -> *mut A {
        &mut self.value
    }

    #[inline(always)]
    pub(crate) fn inc(&mut self) {
        self.count.inc()
    }

    #[inline(always)]
    pub(crate) fn dec(&mut self) -> usize {
        self.count.dec()
    }

    #[inline(always)]
    pub(crate) fn is_shared(&self) -> bool {
        self.count.count() > 1
    }
}