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.

Thsi crate brings serde support for some structs with the feature `serde_support` enabled.

#  Version

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

# Usage

```rust
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](./LICENSE.md).

[`vec_leak`]: https://github.com/rust-lang/rust/issues/62195
[`untagged_unions`]: https://github.com/rust-lang/rust/issues/32836
[`const_fn_union`]: https://github.com/rust-lang/rust/issues/51909
[`const_fn`]: https://github.com/rust-lang/rust/issues/57563
[core::alloc]: https://doc.rust-lang.org/core/alloc/index.html