summaryrefslogtreecommitdiff
path: root/fedora/.local/bin/htop-vim/Vector.c
diff options
context:
space:
mode:
Diffstat (limited to 'fedora/.local/bin/htop-vim/Vector.c')
-rw-r--r--fedora/.local/bin/htop-vim/Vector.c407
1 files changed, 0 insertions, 407 deletions
diff --git a/fedora/.local/bin/htop-vim/Vector.c b/fedora/.local/bin/htop-vim/Vector.c
deleted file mode 100644
index eddbc9a..0000000
--- a/fedora/.local/bin/htop-vim/Vector.c
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
-htop - Vector.c
-(C) 2004-2011 Hisham H. Muhammad
-Released under the GNU GPLv2+, see the COPYING file
-in the source distribution for its full text.
-*/
-
-#include "Vector.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "XUtils.h"
-
-
-Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
- Vector* this;
-
- if (size == DEFAULT_SIZE) {
- size = 10;
- }
-
- assert(size > 0);
- this = xMalloc(sizeof(Vector));
- this->growthRate = size;
- this->array = (Object**) xCalloc(size, sizeof(Object*));
- this->arraySize = size;
- this->items = 0;
- this->type = type;
- this->owner = owner;
- this->dirty_index = -1;
- this->dirty_count = 0;
- return this;
-}
-
-void Vector_delete(Vector* this) {
- if (this->owner) {
- for (int i = 0; i < this->items; i++) {
- if (this->array[i]) {
- Object_delete(this->array[i]);
- }
- }
- }
- free(this->array);
- free(this);
-}
-
-static inline bool Vector_isDirty(const Vector* this) {
- if (this->dirty_count > 0) {
- assert(0 <= this->dirty_index && this->dirty_index < this->items);
- assert(this->dirty_count <= this->items);
- return true;
- }
- assert(this->dirty_index == -1);
- return false;
-}
-
-#ifndef NDEBUG
-
-static bool Vector_isConsistent(const Vector* this) {
- assert(this->items <= this->arraySize);
- assert(!Vector_isDirty(this));
-
- if (this->owner) {
- for (int i = 0; i < this->items; i++) {
- if (!this->array[i]) {
- return false;
- }
- }
- }
-
- return true;
-}
-
-bool Vector_countEquals(const Vector* this, unsigned int expectedCount) {
- unsigned int n = 0;
- for (int i = 0; i < this->items; i++) {
- if (this->array[i]) {
- n++;
- }
- }
- return n == expectedCount;
-}
-
-Object* Vector_get(const Vector* this, int idx) {
- assert(idx >= 0 && idx < this->items);
- assert(this->array[idx]);
- assert(Object_isA(this->array[idx], this->type));
- return this->array[idx];
-}
-
-int Vector_size(const Vector* this) {
- assert(Vector_isConsistent(this));
- return this->items;
-}
-
-#endif /* NDEBUG */
-
-void Vector_prune(Vector* this) {
- assert(Vector_isConsistent(this));
- if (this->owner) {
- for (int i = 0; i < this->items; i++) {
- if (this->array[i]) {
- Object_delete(this->array[i]);
- this->array[i] = NULL;
- }
- }
- }
- this->items = 0;
- this->dirty_index = -1;
- this->dirty_count = 0;
-}
-
-//static int comparisons = 0;
-
-static void swap(Object** array, int indexA, int indexB) {
- assert(indexA >= 0);
- assert(indexB >= 0);
- Object* tmp = array[indexA];
- array[indexA] = array[indexB];
- array[indexB] = tmp;
-}
-
-static int partition(Object** array, int left, int right, int pivotIndex, Object_Compare compare) {
- const Object* pivotValue = array[pivotIndex];
- swap(array, pivotIndex, right);
- int storeIndex = left;
- for (int i = left; i < right; i++) {
- //comparisons++;
- if (compare(array[i], pivotValue) <= 0) {
- swap(array, i, storeIndex);
- storeIndex++;
- }
- }
- swap(array, storeIndex, right);
- return storeIndex;
-}
-
-static void quickSort(Object** array, int left, int right, Object_Compare compare) {
- if (left >= right)
- return;
-
- int pivotIndex = (left + right) / 2;
- int pivotNewIndex = partition(array, left, right, pivotIndex, compare);
- quickSort(array, left, pivotNewIndex - 1, compare);
- quickSort(array, pivotNewIndex + 1, right, compare);
-}
-
-// If I were to use only one sorting algorithm for both cases, it would probably be this one:
-/*
-
-static void combSort(Object** array, int left, int right, Object_Compare compare) {
- int gap = right - left;
- bool swapped = true;
- while ((gap > 1) || swapped) {
- if (gap > 1) {
- gap = (int)((double)gap / 1.247330950103979);
- }
- swapped = false;
- for (int i = left; gap + i <= right; i++) {
- comparisons++;
- if (compare(array[i], array[i+gap]) > 0) {
- swap(array, i, i+gap);
- swapped = true;
- }
- }
- }
-}
-
-*/
-
-static void insertionSort(Object** array, int left, int right, Object_Compare compare) {
- for (int i = left + 1; i <= right; i++) {
- Object* t = array[i];
- int j = i - 1;
- while (j >= left) {
- //comparisons++;
- if (compare(array[j], t) <= 0)
- break;
-
- array[j + 1] = array[j];
- j--;
- }
- array[j + 1] = t;
- }
-}
-
-void Vector_quickSortCustomCompare(Vector* this, Object_Compare compare) {
- assert(compare);
- assert(Vector_isConsistent(this));
- quickSort(this->array, 0, this->items - 1, compare);
- assert(Vector_isConsistent(this));
-}
-
-void Vector_insertionSort(Vector* this) {
- assert(this->type->compare);
- assert(Vector_isConsistent(this));
- insertionSort(this->array, 0, this->items - 1, this->type->compare);
- assert(Vector_isConsistent(this));
-}
-
-static void Vector_checkArraySize(Vector* this) {
- assert(Vector_isConsistent(this));
- if (this->items >= this->arraySize) {
- //int i;
- //i = this->arraySize;
- this->arraySize = this->items + this->growthRate;
- this->array = (Object**) xRealloc(this->array, sizeof(Object*) * this->arraySize);
- //for (; i < this->arraySize; i++)
- // this->array[i] = NULL;
- }
- assert(Vector_isConsistent(this));
-}
-
-void Vector_insert(Vector* this, int idx, void* data_) {
- Object* data = data_;
- assert(idx >= 0);
- assert(Object_isA(data, this->type));
- assert(Vector_isConsistent(this));
-
- if (idx > this->items) {
- idx = this->items;
- }
-
- Vector_checkArraySize(this);
- //assert(this->array[this->items] == NULL);
- if (idx < this->items) {
- memmove(&this->array[idx + 1], &this->array[idx], (this->items - idx) * sizeof(this->array[0]));
- }
- this->array[idx] = data;
- this->items++;
- assert(Vector_isConsistent(this));
-}
-
-Object* Vector_take(Vector* this, int idx) {
- assert(idx >= 0 && idx < this->items);
- assert(Vector_isConsistent(this));
- Object* removed = this->array[idx];
- assert(removed);
- this->items--;
- if (idx < this->items) {
- memmove(&this->array[idx], &this->array[idx + 1], (this->items - idx) * sizeof(this->array[0]));
- }
- //this->array[this->items] = NULL;
- assert(Vector_isConsistent(this));
- return removed;
-}
-
-Object* Vector_remove(Vector* this, int idx) {
- Object* removed = Vector_take(this, idx);
- if (this->owner) {
- Object_delete(removed);
- return NULL;
- } else {
- return removed;
- }
-}
-
-Object* Vector_softRemove(Vector* this, int idx) {
- assert(idx >= 0 && idx < this->items);
-
- Object* removed = this->array[idx];
- assert(removed);
- if (removed) {
- this->array[idx] = NULL;
-
- this->dirty_count++;
- if (this->dirty_index < 0 || idx < this->dirty_index) {
- this->dirty_index = idx;
- }
-
- if (this->owner) {
- Object_delete(removed);
- return NULL;
- }
- }
-
- return removed;
-}
-
-void Vector_compact(Vector* this) {
- if (!Vector_isDirty(this)) {
- return;
- }
-
- const int size = this->items;
- assert(0 <= this->dirty_index && this->dirty_index < size);
- assert(this->array[this->dirty_index] == NULL);
-
- int idx = this->dirty_index;
-
- /* one deletion: use memmove, which should be faster */
- if (this->dirty_count == 1) {
- memmove(&this->array[idx], &this->array[idx + 1], (this->items - idx - 1) * sizeof(this->array[0]));
- } else {
- /* multiple deletions */
- for (int i = idx + 1; i < size; i++) {
- if (this->array[i]) {
- this->array[idx++] = this->array[i];
- }
- }
- }
-
- this->items -= this->dirty_count;
- this->dirty_index = -1;
- this->dirty_count = 0;
-
- assert(Vector_isConsistent(this));
-}
-
-void Vector_moveUp(Vector* this, int idx) {
- assert(idx >= 0 && idx < this->items);
- assert(Vector_isConsistent(this));
-
- if (idx == 0)
- return;
-
- Object* temp = this->array[idx];
- this->array[idx] = this->array[idx - 1];
- this->array[idx - 1] = temp;
-}
-
-void Vector_moveDown(Vector* this, int idx) {
- assert(idx >= 0 && idx < this->items);
- assert(Vector_isConsistent(this));
-
- if (idx == this->items - 1)
- return;
-
- Object* temp = this->array[idx];
- this->array[idx] = this->array[idx + 1];
- this->array[idx + 1] = temp;
-}
-
-void Vector_set(Vector* this, int idx, void* data_) {
- Object* data = data_;
- assert(idx >= 0);
- assert(Object_isA(data, this->type));
- assert(Vector_isConsistent(this));
-
- Vector_checkArraySize(this);
- if (idx >= this->items) {
- this->items = idx + 1;
- } else {
- if (this->owner) {
- Object* removed = this->array[idx];
- assert (removed != NULL);
- Object_delete(removed);
- }
- }
- this->array[idx] = data;
- assert(Vector_isConsistent(this));
-}
-
-/*
-
-static void Vector_merge(Vector* this, Vector* v2) {
- int i;
- assert(Vector_isConsistent(this));
-
- for (i = 0; i < v2->items; i++)
- Vector_add(this, v2->array[i]);
- v2->items = 0;
- Vector_delete(v2);
- assert(Vector_isConsistent(this));
-}
-
-*/
-
-void Vector_add(Vector* this, void* data_) {
- Object* data = data_;
- assert(Object_isA(data, this->type));
- assert(Vector_isConsistent(this));
- int i = this->items;
- Vector_set(this, this->items, data);
- assert(this->items == i + 1); (void)(i);
- assert(Vector_isConsistent(this));
-}
-
-int Vector_indexOf(const Vector* this, const void* search_, Object_Compare compare) {
- const Object* search = search_;
- assert(Object_isA(search, this->type));
- assert(compare);
- assert(Vector_isConsistent(this));
- for (int i = 0; i < this->items; i++) {
- const Object* o = this->array[i];
- assert(o);
- if (compare(search, o) == 0) {
- return i;
- }
- }
- return -1;
-}
-
-void Vector_splice(Vector* this, Vector* from) {
- assert(Vector_isConsistent(this));
- assert(Vector_isConsistent(from));
- assert(!(this->owner && from->owner));
-
- int olditems = this->items;
- this->items += from->items;
- Vector_checkArraySize(this);
- for (int j = 0; j < from->items; j++) {
- this->array[olditems + j] = from->array[j];
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-28 11:10:06 +0000