memapi 0.13.1

A no_std-friendly memory allocation interface for raw buffers, with improved error reporting.
Documentation 
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

# memapi

![crates.io](https://img.shields.io/crates/v/memapi.svg) ![docs.rs](https://docs.rs/memapi/badge.svg)

A minimal, `no_std`-friendly memory allocation interface for managing raw buffers, suitable for use in collections.

MSRV: 1.56.0

# note: this readme is ***VERY*** outdated

---

## Features

* **Error reporting via `AllocError`**
* **`no_std` compatible**
* Optional **nightly/allocator_api** support via `allocator_api` feature
* **Extension methods** via `alloc_ext` feature
* Optional **unstable utilities** via `unstable_util` feature
* Optional **allocation statistics** via `stats` feature
* Zero-cost wrapper over the global allocator
* Fall-back implementation for stable Rust
* Allocation, deallocation, grow/shrink, and realloc operations

---

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
memapi = "0.13.1"
```

Or, the recommended way:

```toml
[features]
allocator_api = ["memapi/nightly"]

[dependencies]
memapi = "0.13.1"
```

---

## API

### Trait: `Alloc`

Defines the minimal allocation interface. Methods include:

* `alloc(layout) -> Result<NonNull<u8>, AllocError>`
    * `alloc_zeroed(layout) -> Result<NonNull<u8>, AllocError>`
    * `alloc_filled(layout, u8) -> Result<NonNull<u8>, AllocError>`
    * `alloc_patterned(layout, F) -> Result<NonNull<u8>, AllocError>`
* `alloc_count<T>(count) -> Result<NonNull<T>, AllocError>`
    * `alloc_count_zeroed<T>(count)`
    * `alloc_count_filled<T>(count, u8)`
    * `alloc_count_patterned<T, F>(count, pattern)`
* `dealloc(ptr, layout)`
    * `drop_and_dealloc<T: ?Sized>(ptr)`
* `grow`
    * `grow_zeroed`
    * `grow_filled`
    * `grow_patterned`
* `shrink`
* `realloc`
    * `realloc_zeroed`
    * `realloc_filled`
    * `realloc_patterned`

### Trait: `AllocExt` (feature = `alloc_ext`)

Extension methods built on top of `Alloc` for common allocation patterns:

* `alloc_write<T>(data: T) -> Result<NonNull<T>, AllocError>`
* `alloc_clone_to<T: Clone>(&T) -> Result<NonNull<T>, AllocError>`
* `alloc_clone_slice_to<T: Clone>(&[T]) -> Result<NonNull<[T]>, AllocError>`
* `alloc_slice_with<T, F: Fn(usize) -> T>(usize, F) -> Result<NonNull<[T]>, AllocError>`
* Deallocation helpers for slices and values
* Safe and unsafe variants for copying unsized data

### Traits and Utilities

* `Thin` – Marker trait for pointers with no metadata
* `UnsizedCopy` – Marker trait for safely copying raw memory
* `SizedProps` – Compile-time constants (`SZ`, `ALIGN`, `LAYOUT`, `IS_ZST`, `MAX_SLICE_LEN`) for sized types
* `PtrProps<T: ?Sized>` – Query size, alignment, layout, ZST-status, max slice length, and metadata of pointers

---

## No-Std Support

This crate works without the Rust standard library. It relies on `alloc` from the core
distribution.

---

## Documentation

* [API Reference on docs.rs](https://docs.rs/memapi)
* In-code documentation with a feature set via `cargo doc --open` with feature flags

---

## License

Licensed under **Apache-2.0** OR **MIT**. See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT).