[−][src]Crate compact_arena
A crate with a few single-typed arenas that work exclusively with indexes. The indexes are sized with the arena. This can reduce memory footprint when changing pointers to indices e.g. on 64-bit systems.
The arenas use a variant of "branded indices": The indices contain a type
tag that binds them to their respective arena so you cannot mix up two
arenas by accident. Unlike the indexing
crate, this implements the type tags as actual unique types. This has the
downside of not being able to Sync
or Send
arenas or indices, but on the
other hand, we can store indices within objects that we put into the arena,
which is a boon to things like graph data structures.
A word of warning: The soundness of this isn't proven, and it may well be possible to use the macros provided in this crate to create undefined behavior. For simple use cases, you should be pretty safe.
Use the in_arena
and similar methods to run code within the scope of an
arena:
Examples
in_arena!(arena, { let idx = arena.add(1usize); assert_eq!(1, arena[idx]); });
You can use in_sized_arena
to change the initial size of the backing
memory:
in_arena!(arena / 1, { .. });
You can nest calls to work with multiple arenas:
in_arena!(a / 1, { in_arena!(b / 1, { .. }) });
The compiler gives you a type error if you mix up arenas:
in_arena!(a / 1, { in_arena!(b / 1, { let i = a.add(1usize); let _ = b[i]; }) });
Macros
in_arena | Run code using an arena. The indirection through the macro is required
to safely bind the indices to the arena. The macro takes an identifier that
will be bound to the |
in_nano_arena | Run code using a nano arena. The indirection through the macro is required to bind the indices to the arena. |
in_tiny_arena | Run code using a tiny arena. The indirection through this macro is required to bind the indices to the arena. |
Structs
Idx | An index into the arena. You will not directly use this type, but one of
the aliases this crate provides ( |
NanoArena | A "nano" arena containing 255 elements. This variant only works with
types implementing |
SmallArena | A "Small" arena based on a resizable slice (i.e. a |
TinyArena | A "tiny" arena containing <64K elements. This variant only works with
types implementing |
Type Definitions
Idx8 | The index type for a nano arena is 8 bits large. You will usually get the
index from the arena and use it by indexing, e.g. |
Idx16 | The index type for a tiny arena is 16 bits large. You will usually get the
index from the arena and use it by indexing, e.g. |
Idx32 | The index type for a small arena is 32 bits large. You will usually get the
index from the arena and use it by indexing, e.g. |