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

//! Data types for zone-based (also known as region-based or arena-based) data allocation.
//!
//! # Examples
//!
//! ## Linked List Nodes with [`Arena<T>`]
//! ```
//! use zone_alloc::Arena;
//!
//! #[derive(Debug, PartialEq, Eq)]
//! struct Node<'a, T> {
//!     parent: Option<&'a Node<'a, T>>,
//!     value: T,
//! }
//!
//! impl<'a, T> Node<'a, T> {
//!     pub fn new(parent: Option<&'a Node<'a, T>>, value: T) -> Self {
//!         Self { parent, value }
//!     }
//! }
//!
//! fn main() {
//!     let arena = Arena::new();
//!     let node = arena.alloc(Node::new(None, 1));
//!     let node = arena.alloc(Node::new(Some(node), 2));
//!     let node = arena.alloc(Node::new(Some(node), 3));
//!
//!     assert_eq!(node.value, 3);
//!     assert_eq!(node.parent.unwrap().value, 2);
//!     assert_eq!(node.parent.unwrap().parent.unwrap().value, 1);
//!     assert_eq!(node.parent.unwrap().parent.unwrap().parent, None);
//! }
//! ```
//!
//! ## Circular References with [`Registry<T>`]
//! ```
//! use zone_alloc::{
//!     Handle,
//!     Registry,
//! };
//!
//! #[derive(Debug, PartialEq, Eq)]
//! struct Node<T> {
//!     parent: Option<Handle>,
//!     value: T,
//! }
//!
//! impl<T> Node<T> {
//!     pub fn new(parent: Option<Handle>, value: T) -> Self {
//!         Self { parent, value }
//!     }
//! }
//!
//! fn main() {
//!     let registry = Registry::new();
//!     let root_handle = registry.register(Node::new(None, "first"));
//!     let handle = registry.register(Node::new(Some(root_handle), "second"));
//!     let handle = registry.register(Node::new(Some(handle), "third"));
//!     registry.get_mut(root_handle).unwrap().parent = Some(handle);
//!
//!     let node = registry.get(handle).unwrap();
//!     assert_eq!(node.value, "third");
//!     let node = registry.get(node.parent.unwrap()).unwrap();
//!     assert_eq!(node.value, "second");
//!     let node = registry.get(node.parent.unwrap()).unwrap();
//!     assert_eq!(node.value, "first");
//!     let node = registry.get(node.parent.unwrap()).unwrap();
//!     assert_eq!(node.value, "third");
//! }
//! ```
#![cfg_attr(not(feature = "std"), no_std)]

pub mod arena;
pub mod registry;
mod strong_registry;

pub use arena::Arena;
pub use registry::{
    Handle,
    Registry,
};
pub use strong_registry::{
    StrongHandle,
    StrongRegistry,
};