Crates.io | memur |
lib.rs | memur |
version | 0.1.2 |
source | src |
created_at | 2020-10-29 10:35:10.479659 |
updated_at | 2020-10-29 18:34:40.247615 |
description | Arena storage with bells and whistles. |
homepage | |
repository | https://github.com/Nercury/memur |
max_upload_size | |
id | 306601 |
size | 108,902 |
Arena storage with its own basic allocator, managed drop order, efficient and optional drop execution, universal string, list, array, and custom structure/data support.
See more comprehensive writeup in crate documentation.
Some idea of how the usage looks like:
use memur::{Memory, Arena, UStr};
fn main() {
// memory pool which can be shared between threads
let mem = Memory::new();
{
let arena = Arena::new(&mem).unwrap();
// Zero-terminated utf-8 string that does not need
// to be dropped:
let text = UStr::from_str(&arena, "Hello").unwrap();
assert_eq!("Hello", &text);
// Since it is zero-terminated,
// it can be used in C APIs without conversion:
assert_eq!(unsafe { CStr::from_bytes_with_nul_unchecked(b"Hello\n") }, &text);
// Simple struct wrapper, items added this way end up
// near each other in memory:
let a = N::new(&arena, "hello").unwrap();
let b = N::new(&arena, "world").unwrap();
// This also adds another item "c" to the same arena, which
// will be dropped after the "a" is dropped.
// This is useful for ensuring the drop order.
let c = a.outlives("c").unwrap();
// Fixed size array example, initialized
// from exact size iterator:
let a = Array::new(&arena, (0..2).into_iter()).unwrap();
assert_eq!(a.len(), Some(2));
// The unsafe C-way to initialize array is also available:
let mut uninitialized_array = Array::<i32>::with_capacity(&arena, 2).unwrap();
unsafe { *(uninitialized_array.data_mut().offset(0)) = 1 }
unsafe { *(uninitialized_array.data_mut().offset(1)) = 2 }
let a = unsafe { uninitialized_array.initialized_to_len(2) };
assert_eq!(a.len(), Some(2));
assert_eq!(a[0], 1);
assert_eq!(a[1], 2);
// The drop functions are executed when the Arena goes out of scope,
// and the created objects are aware of that because they keep
// WeakArena inside.
// The memory blocks are returned back to Memory when
// all WeakArena holders go out of scope.
}
}
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.