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
//! # Inplace it!
//!
//! Place small arrays on the stack with a low cost!
//!
//! The only price you should pay for this is the price of choosing
//! a type based on the size of the requested array! This is just one `match`!
//!
//! ## What?
//!
//! This crate is created for one purpose: allocating small arrays on the stack.
//! The simplest way to use it is:
//!
//! ```rust
//! use inplace_it::{inplace_or_alloc_array, UninitializedSliceMemoryGuard};
//!
//! inplace_or_alloc_array(
//! 150, // size of needed array to allocate
//! |mut uninit_guard: UninitializedSliceMemoryGuard<u16>| { // and this is consumer of uninitialized memory
//! assert_eq!(160, uninit_guard.len());
//!
//! {
//! // You can borrow guard to reuse memory
//! let borrowed_uninit_guard = uninit_guard.borrow();
//! // Let's initialize memory
//! // Note that borrowed_uninit_guard will be consumed (destroyed to produce initialized memory guard)
//! let init_guard = borrowed_uninit_guard.init(|index| index as u16 + 1);
//! // Memory now contains elements [1, 2, ..., 160]
//! // Lets check it. Sum of [1, 2, ..., 160] = 12880
//! let sum: u16 = init_guard.iter().sum();
//! assert_eq!(sum, 12880);
//! }
//!
//! {
//! // If you don't want to reuse memory, you can init new guard directly
//! let init_guard = uninit_guard.init(|index| index as u16 * 2);
//! // Memory now contains elements [0, 2, 4, ..., 318]
//! // Lets check it. Sum of [0, 2, 4, ..., 318] = 25440
//! let sum: u16 = init_guard.iter().sum();
//! assert_eq!(sum, 25440);
//! }
//! }
//! )
//! ```
//!
//! ## Why?
//!
//! Because allocation on the stack (i.e. placing variables) is **MUCH FASTER** then usual
//! allocating in the heap.
//!
pub use *;
pub use *;
pub use *;