Struct inplace_it::SliceMemoryGuard

pub struct SliceMemoryGuard<'a, T> { /* fields omitted */ }

Guard-struct used for correctly initialize uninitialized memory and drop it when guard goes out of scope. Usually, you should not use this struct to handle your memory.

Safety

If you use this struct manually, remember: &mut [MaybeUninit<T>]'s content will be overwriten while initialization. So it is not safe to apply this struct to already initialized data and it can lead to memory leaks.

Example

use inplace_it::SliceMemoryGuard;
use std::mem::MaybeUninit;

// Placing uninitialized memory
let mut memory: [MaybeUninit<usize>; 100] = unsafe { MaybeUninit::uninit().assume_init() };
// Initializing guard
let mut memory_guard = unsafe {
    SliceMemoryGuard::new(
        // Borrowing memory
        &mut memory,
        // Forwarding initializer
        |index| index * 2
    )
};

// For now, memory contains content like [0, 2, 4, 6, ..., 196, 198]

// Using memory
// Sum of [0, 2, 4, 6, ..., 196, 198] = sum of [0, 1, 2, 3, ..., 98, 99] * 2 = ( 99 * (99+1) ) / 2 * 2
let sum: usize = memory_guard.iter().sum();
assert_eq!(sum, 99 * 100);

Implementations

impl<'a, T> SliceMemoryGuard<'a, T>

pub unsafe fn new(
    memory: &'a mut [MaybeUninit<T>],
    init: impl FnMut(usize) -> T
) -> Self

Initialize memory guard

Trait Implementations

impl<'a, T> Deref for SliceMemoryGuard<'a, T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> DerefMut for SliceMemoryGuard<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T> Drop for SliceMemoryGuard<'a, T>

fn drop(&mut self)

Executes the destructor for this type.