static void Expand(UnsafeStack *stack) { // new buffer for elements UnsafeBuffer newItems = default; // initialize to double size of existing one UnsafeBuffer.InitDynamic(&newItems, stack->_items.Length * 2, stack->_items.Stride); // copy memory over from previous items UnsafeBuffer.Copy(stack->_items, 0, newItems, 0, stack->_items.Length); // free old buffer UnsafeBuffer.Free(&stack->_items); // replace buffer with new stack->_items = newItems; }
static void Expand(UnsafeOrderedCollection *collection) { Assert.Check(collection->Entries.Dynamic == 1); Assert.Check(collection->FreeCount == 0); Assert.Check(collection->FreeHead == 0); var capacity = collection->Entries.Length * 2; var newEntries = default(UnsafeBuffer); UnsafeBuffer.InitDynamic(&newEntries, capacity, collection->Entries.Stride); UnsafeBuffer.Copy(collection->Entries, 0, newEntries, 0, collection->Entries.Length); // free old memory UnsafeBuffer.Free(&collection->Entries); // new storage collection->Entries = newEntries; }
public static void Free(UnsafeQueue *queue) { if (queue == null) { return; } // not fixed, we need to free items separtely if (queue->_items.Dynamic == 1) { UnsafeBuffer.Free(&queue->_items); } // clear queue memory (just in case) *queue = default; // free queue memory, if this is a fixed queue it frees the items memory at the same time Native.Free(queue); }
public static void Free(UnsafeHeapMax *heap) { if (heap == null) { return; } // free dynamic items separately if (heap->_items.Dynamic == 1) { UnsafeBuffer.Free(&heap->_items); } // clear memory *heap = default; // free heap Native.Free(heap); }
static void ExpandHeap(UnsafeHeapMin *heap) { Assert.Check(heap->_items.Dynamic == 1); // new buffer for elements UnsafeBuffer newItems = default; // initialize to double size of existing one UnsafeBuffer.InitDynamic(&newItems, heap->_items.Length * 2, heap->_items.Stride); // copy memory over from previous items UnsafeBuffer.Copy(heap->_items, 0, newItems, 0, heap->_items.Length); // free old buffer UnsafeBuffer.Free(&heap->_items); // replace buffer with new heap->_items = newItems; }
// expand algorithm from first answer here: https://codereview.stackexchange.com/questions/129819/queue-resizing-array-implementation static void Expand(UnsafeQueue *queue, int capacity) { Assert.Check(capacity > 0); // queue has to be dynamic and capacity we're going to have to be larger Assert.Check(queue->_items.Dynamic == 1); Assert.Check(queue->_items.Length < capacity); // new buffer for elements UnsafeBuffer newItems = default; // initialize to double size of existing one UnsafeBuffer.InitDynamic(&newItems, capacity, queue->_items.Stride); if (queue->_count > 0) { // when head is 'ahead' or at tail it means that we're wrapping around if (queue->_head >= queue->_tail) { // so we need to copy head first, from (head, length-head) into (0, length-head) UnsafeBuffer.Copy(queue->_items, queue->_head, newItems, 0, queue->_items.Length - queue->_head); // and then copy tail, from (0, tail) into (length-head, tail) UnsafeBuffer.Copy(queue->_items, 0, newItems, queue->_items.Length - queue->_head, queue->_tail); } else { // if not, we can just copy from (tail, count) into (0, count) UnsafeBuffer.Copy(queue->_items, queue->_head, newItems, 0, queue->_count); } } // free existing buffer UnsafeBuffer.Free(&queue->_items); queue->_items = newItems; queue->_head = 0; queue->_tail = queue->_count % queue->_items.Length; }
public static void Free(UnsafeHashMap *map) { AllocHelper.Free(map->_collection.Buckets); AllocHelper.Free(map->_collection.FreeHead); UnsafeBuffer.Free(&map->_collection.Entries); }