This crate provides high-level memory abstractions used for ensure memory and exception safety in some patterns.

It brings safe abstractions for some cases of transmute and others unsafe functions in the mem or ptr module,does not provide a custom allocator or garbage collector neither depends on the [core::alloc] unstable lib.

Version

At the moment this crate is nightly only,this will change if the features vec_leak, const_fn, untagged_unions and manually_drop_take get stabilished.

Usage

use high_mem_utils::{Catch, DontDropOpt, DropBy};

let mut string = String::from("Hello world!");
let catch = Catch::new_str(string.clone());

assert_eq!(catch.leaked().to_string(), string); // leaked returns &&mut str,not use to_string
                                                // it's a bit difficult cast rigth now

assert_eq!(catch.seal(), string); // catch consumed
let mut a = [1, 2, 3];

{
    let elem = DropBy::new([2, 3, 4], |e: [u32; 3]| { a = e.clone(); });

    assert_eq!(*elem, Some([2, 3, 4]));
}

assert_eq!(a, [2, 3, 4]);

unsafe {
    let b = DontDropOpt::new([1, 2, 3]); // we're not dropping here because we will have two variables
                                 // pointing to the same memory and "b" lives for shorter
    a = [0; 3];
    b.as_ref().unwrap().as_ptr().copy_to(a.as_mut_ptr(), 3);
}

assert_eq!(a, [1, 2, 3]);

License

This code is licensed under the Unlicense.