Struct NodeField

pub struct NodeField<T: Clone> { /* private fields */ }

Used to allocate space on the heap, read from that space, and write to it.

Implementations

impl<T: Clone> NodeField<T>

pub fn new() -> Self

Constructs a new NodeField which can store data of type T

Example

//Stores i32s
let mut storage = NodeField::<i32>::new();

pub fn data<I: Indexable>(&self, index: I) -> Result<&T, AccessError>

Returns an immutable reference to the data stored at the requested index, or an AccessError if there is a problem.

pub fn mut_data<I: Indexable>( &mut self, index: I, ) -> Result<&mut T, AccessError>

Returns a mutable reference to the data stored at the requested index, or an AccessError if there is a problem.

pub fn add_ref<I: Indexable>(&mut self, index: I) -> Result<(), AccessError>

Tells the NodeField that something else references the data at index. So long as the NodeField thinks there is at least one reference, the data won’t be freed.

Failure to properly track references will lead to either freeing data you wanted or leaking data you didn’t.

pub fn remove_ref<I: Indexable>( &mut self, index: I, ) -> Result<Option<T>, AccessError>

Tells the NodeField that something no longer references the data at index. If calling this function renders the refcount 0, the data will be freed and returned.

Failure to properly track references will lead to either freeing data you wanted or leaking data you didn’t.

pub fn status<I: Indexable>(&self, index: I) -> Result<usize, AccessError>

Returns the number of references the data at index has or an AccessError if the request has a problem

pub fn push(&mut self, data: T) -> usize

Pushes data into the NodeField, returning the index it was stored at.

Once you recieve the index the data was stored at, it is your responsibility to manage its references. The data will start with one reference.

pub fn replace<I: Indexable>( &mut self, index: I, new_data: T, ) -> Result<T, AccessError>

Replaces the data at index with new_data, returning the replaced data on success and an AccessError on failure. You may not replace an index which is currently free.

pub fn next_allocated(&self) -> usize

Returns the next index which will be allocated on a NodeField::push call

pub fn repair_allocator(&mut self)

Travels through each slot in the vec checks whether it currently contains data, updating the allocator accordingly.

pub fn defrag(&mut self) -> HashMap<usize, usize>

Travels through memory and re-arranges slots so that they are contiguous in memory, with no free slots in between occupied ones. The hashmap returned can be used to remap your references to their new locations. (Key:Old, Value:New)

Slots at the back of memory will be placed in the first free slot, until the above condition is met.

This operation is O(n) to the number of slots in memory.

pub fn trim(&mut self) -> HashMap<usize, usize>

NodeField::defrags the memory, then shrinks the internal memory Vec to the size of the block of occupied memory.

pub fn allocation_map(&self) -> &Vec<usize>

Returns a reference to the current bitfield of allocated/free memory slots

pub fn memory(&self) -> &Vec<Option<Steward<T>>>

Returns a reference to the internal memory Vec

Trait Implementations

impl<T: Debug + Clone> Debug for NodeField<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for NodeField<T>

where T: Deserialize<'de> + Clone,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for NodeField<T>

where T: Serialize + Clone,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.