moveref 1.0.0

Types and traits for safe C++ style placement initialization and move semantics
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

use core::{mem::MaybeUninit, pin::Pin};

use crate::{
    move_ref::MoveRef,
    new::{New, TryNew},
    slot_storage::SlotStorageStatus,
};

/// Backing storage for a [`MoveRef`].
pub struct Slot<'frame, T> {
    /// The raw underlying (possibily uninitialized) storage memory.
    pub(crate) memory: &'frame mut MaybeUninit<T>,
    /// Status flags for the storage which track initialization, dropping state, and reference count.
    pub(crate) status: SlotStorageStatus<'frame>,
}

impl<'frame, T> Slot<'frame, T> {
    /// Construct and pin `new` into the slot and return the associated owning [`MoveRef`].
    #[inline]
    pub fn emplace<N: New<Output = T>>(self, new: N) -> Pin<MoveRef<'frame, T>> {
        match self.try_emplace(new) {
            | Ok(pin) => return pin,
            | Err(err) => match err {},
        }
    }

    /// Try to construct and pin `new` into the slot and return the associated owning [`MoveRef`].
    ///
    /// # Errors
    ///
    /// Should return `Err` if the `new` initializer fails with an error.
    #[inline]
    pub fn try_emplace<N: TryNew<Output = T>>(
        self,
        new: N,
    ) -> Result<Pin<MoveRef<'frame, T>>, N::Error> {
        self.status.initialize();
        unsafe { new.try_new(Pin::new_unchecked(self.memory))? };
        let ptr = unsafe { self.memory.assume_init_mut() };
        let mov = unsafe { MoveRef::new_unchecked(ptr, self.status) };
        let pin = mov.into_pin();
        return Ok(pin);
    }

    /// Move and pin `val` into the slot and return the associated owning [`MoveRef`].
    #[inline]
    pub fn pin(self, val: T) -> Pin<MoveRef<'frame, T>> {
        return self.emplace(crate::new::of(val));
    }

    /// Move `val` into the slot and return the associated owning [`MoveRef`].
    #[inline]
    pub fn put(self, val: T) -> MoveRef<'frame, T> {
        let pin = self.pin(val);
        return unsafe { Pin::into_inner_unchecked(pin) }; // tarpaulin
    }

    /// Write `val` into the slot and returns a `&mut ref` to its location and its storage status.
    #[inline]
    pub(crate) fn write(self, val: T) -> (&'frame mut T, SlotStorageStatus<'frame>) {
        self.status.initialize();
        let ptr = self.memory.write(val);
        return (ptr, self.status);
    }
}