realloc 0.1.0

A re-implementation of various ::alloc features
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

use core::ops::{Deref, DerefMut};

use crate::{Alloc, Allocator, AllocatorExt, Error, Panic, Strategy};

/// A pointer type that uniquely owns an allocation of type `T`.
///
/// Note that this does not have the full API surface of `std::box::Box`,
/// largely due to the fact that `std::box::Box` has built-in compiler magic.
pub struct Box<'alloc, T, S: Strategy> {
    alloc: Option<Alloc<'alloc, T>>,
    _strategy: S,
}

#[cfg(feature = "global")]
impl<T, S: Strategy> Box<'static, T, S> {
    /// Allocates `value` in the global allocator.
    ///
    /// Fails if there is no global allocator.
    ///
    /// Only available on feature `global`.
    pub fn new(value: T) -> S::Result<Self, Error> {
        let allocator = S::create(crate::global::get().ok_or(Error::NoGlobalAllocator));
        S::and_then(allocator, |allocator| Self::new_in(value, allocator))
    }
}

impl<'alloc, T, S: Strategy> Box<'alloc, T, S> {
    /// Allocates `value` in the given allocator.
    pub fn new_in(value: T, allocator: &'alloc dyn Allocator) -> S::Result<Self, Error> {
        let alloc = S::create(allocator.alloc_with(value));
        let alloc = S::map(alloc, |alloc| Self {
            alloc: Some(alloc),
            _strategy: S::UNIT,
        });
        S::map_err(alloc, |(_, e)| e)
    }

    /// Creates a clone of this box in the given allocator.
    ///
    /// If you want to clone it in a different allocator, see
    /// [`clone_in`](Self::clone_in).
    pub fn clone_in<'new_alloc>(
        &self,
        allocator: &'new_alloc dyn Allocator,
    ) -> S::Result<Box<'new_alloc, T, S>, Error>
    where
        T: Clone,
    {
        let value = self.deref().clone();
        Box::<T, S>::new_in(value, allocator)
    }

    /// Creates a clone of this box in the same allocator it was created in.
    ///
    /// If you want to clone it in a different allocator, see
    /// [`clone_in`](Self::clone_in).
    pub fn clone_in_same(&self) -> S::Result<Self, Error>
    where
        T: Clone,
    {
        self.clone_in(self.alloc.as_ref().unwrap().allocator())
    }

    /// Change the [failure strategy](Strategy) employed on fallible methods.
    pub fn change_strategy<NS: Strategy>(mut self) -> Box<'alloc, T, NS> {
        let alloc = self.alloc.take();
        Box {
            alloc,
            _strategy: NS::UNIT,
        }
    }

    /// Deallocate the box, returning the inner value.
    ///
    /// A substitute for `*box` in `std::box::Box`.
    pub fn take(mut self) -> T {
        let alloc = self.alloc.take().unwrap();
        // SAFETY: the value is deallocated without being dropped
        let value = unsafe { alloc.as_ptr().read() };
        alloc.dealloc();
        value
    }

    /// Consumes and leaks the box, returning a mutable reference,
    /// `&'alloc mut T`.
    ///
    /// Note that this *will* cause a memory leak; as such, be wary of using
    /// this repeatedly, unless you intend on dropping/clearing the underlying
    /// allocator.
    pub fn leak(this: Self) -> &'alloc mut T {
        let mut this = core::mem::ManuallyDrop::new(this);

        // SAFETY: this allocation will now never be freed, so the data will
        // live as long as the underlying allocator
        unsafe { &mut *this.alloc.take().unwrap().as_ptr() }
    }
}

impl<T: Clone, S: Strategy> Clone for Box<'_, T, S> {
    fn clone(&self) -> Self {
        let value = self.deref().clone();
        Box::<_, Panic>::new_in(value, self.alloc.as_ref().unwrap().allocator()).change_strategy()
    }
}

impl<T, S: Strategy> Deref for Box<'_, T, S> {
    type Target = T;

    fn deref(&self) -> &T {
        // SAFETY: it's guaranteed to be initialized
        unsafe { self.alloc.as_ref().unwrap().as_ref() }
    }
}

impl<T, S: Strategy> DerefMut for Box<'_, T, S> {
    fn deref_mut(&mut self) -> &mut T {
        // SAFETY: it's guaranteed to be initialized
        unsafe { self.alloc.as_mut().unwrap().as_mut() }
    }
}

impl<T, S: Strategy> Drop for Box<'_, T, S> {
    fn drop(&mut self) {
        let alloc = self.alloc.take().unwrap();
        // SAFETY: the alloc is deallocated without its value being dropped
        drop(unsafe { alloc.as_ptr().read() });
        alloc.dealloc();
    }
}