htop/Vector.c

326 lines
8.2 KiB
C
Raw Normal View History

2006-03-04 18:16:49 +00:00
/*
2011-12-26 21:35:57 +00:00
htop - Vector.c
2011-05-26 16:35:07 +00:00
(C) 2004-2011 Hisham H. Muhammad
Released under the GNU GPLv2, see the COPYING file
2006-03-04 18:16:49 +00:00
in the source distribution for its full text.
*/
#include "Vector.h"
2006-03-04 18:16:49 +00:00
#include <assert.h>
2011-12-26 21:35:57 +00:00
#include <stdlib.h>
#include <string.h>
#include "XUtils.h"
2006-03-04 18:16:49 +00:00
Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
Vector* this;
2006-03-04 18:16:49 +00:00
if (size == DEFAULT_SIZE)
size = 10;
assert(size > 0);
2016-02-02 14:53:02 +00:00
this = xMalloc(sizeof(Vector));
2006-03-04 18:16:49 +00:00
this->growthRate = size;
2016-02-02 14:53:02 +00:00
this->array = (Object**) xCalloc(size, sizeof(Object*));
2006-03-04 18:16:49 +00:00
this->arraySize = size;
this->items = 0;
this->type = type;
2006-03-04 18:16:49 +00:00
this->owner = owner;
return this;
}
void Vector_delete(Vector* this) {
2006-03-04 18:16:49 +00:00
if (this->owner) {
for (int i = 0; i < this->items; i++)
if (this->array[i])
Object_delete(this->array[i]);
2006-03-04 18:16:49 +00:00
}
free(this->array);
free(this);
}
#ifndef NDEBUG
static bool Vector_isConsistent(const Vector* this) {
2006-11-08 21:47:11 +00:00
assert(this->items <= this->arraySize);
2006-03-04 18:16:49 +00:00
if (this->owner) {
for (int i = 0; i < this->items; i++)
if (this->array[i] && !Object_isA(this->array[i], this->type))
2006-03-04 18:16:49 +00:00
return false;
return true;
} else {
return true;
}
}
int Vector_count(const Vector* this) {
2006-11-12 21:52:14 +00:00
int items = 0;
for (int i = 0; i < this->items; i++) {
if (this->array[i])
items++;
}
assert(items == this->items);
return items;
}
Object* Vector_get(Vector* this, int idx) {
assert(idx < this->items);
assert(Vector_isConsistent(this));
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) {
2014-04-21 22:01:15 +00:00
for (int i = 0; i < this->items; i++)
if (this->array[i]) {
Object_delete(this->array[i]);
//this->array[i] = NULL;
}
}
2006-03-04 18:16:49 +00:00
this->items = 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));
2006-03-04 18:16:49 +00:00
}
static void Vector_checkArraySize(Vector* this) {
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
if (this->items >= this->arraySize) {
//int i;
//i = this->arraySize;
2006-03-04 18:16:49 +00:00
this->arraySize = this->items + this->growthRate;
2016-02-02 14:53:02 +00:00
this->array = (Object**) xRealloc(this->array, sizeof(Object*) * this->arraySize);
//for (; i < this->arraySize; i++)
// this->array[i] = NULL;
2006-03-04 18:16:49 +00:00
}
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
void Vector_insert(Vector* this, int idx, void* data_) {
2006-03-04 18:16:49 +00:00
Object* data = data_;
assert(idx >= 0);
assert(Object_isA(data, this->type));
assert(Vector_isConsistent(this));
if (idx > this->items) {
idx = this->items;
}
2019-10-31 16:39:12 +00:00
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]));
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
this->array[idx] = data;
2006-03-04 18:16:49 +00:00
this->items++;
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
Object* Vector_take(Vector* this, int idx) {
assert(idx >= 0 && idx < this->items);
assert(Vector_isConsistent(this));
2010-02-25 01:43:18 +00:00
Object* removed = this->array[idx];
assert(removed);
2006-03-04 18:16:49 +00:00
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));
2006-03-04 18:16:49 +00:00
return removed;
}
2010-02-25 01:43:18 +00:00
Object* Vector_remove(Vector* this, int idx) {
Object* removed = Vector_take(this, idx);
2006-03-04 18:16:49 +00:00
if (this->owner) {
Object_delete(removed);
2006-03-04 18:16:49 +00:00
return NULL;
} else
return removed;
}
2010-02-25 01:43:18 +00:00
void Vector_moveUp(Vector* this, int idx) {
assert(idx >= 0 && idx < this->items);
assert(Vector_isConsistent(this));
2010-02-25 01:43:18 +00:00
if (idx == 0)
2006-03-04 18:16:49 +00:00
return;
2010-02-25 01:43:18 +00:00
Object* temp = this->array[idx];
this->array[idx] = this->array[idx - 1];
this->array[idx - 1] = temp;
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
void Vector_moveDown(Vector* this, int idx) {
assert(idx >= 0 && idx < this->items);
assert(Vector_isConsistent(this));
2010-02-25 01:43:18 +00:00
if (idx == this->items - 1)
2006-03-04 18:16:49 +00:00
return;
2010-02-25 01:43:18 +00:00
Object* temp = this->array[idx];
this->array[idx] = this->array[idx + 1];
this->array[idx + 1] = temp;
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
void Vector_set(Vector* this, int idx, void* data_) {
2006-03-04 18:16:49 +00:00
Object* data = data_;
assert(idx >= 0);
assert(Object_isA(data, this->type));
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
Vector_checkArraySize(this);
2010-02-25 01:43:18 +00:00
if (idx >= this->items) {
this->items = idx+1;
2006-03-04 18:16:49 +00:00
} else {
if (this->owner) {
2010-02-25 01:43:18 +00:00
Object* removed = this->array[idx];
2006-03-04 18:16:49 +00:00
assert (removed != NULL);
if (this->owner) {
Object_delete(removed);
2006-03-04 18:16:49 +00:00
}
}
}
2010-02-25 01:43:18 +00:00
this->array[idx] = data;
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
/*
static void Vector_merge(Vector* this, Vector* v2) {
2006-03-04 18:16:49 +00:00
int i;
assert(Vector_isConsistent(this));
2019-10-31 16:39:12 +00:00
2006-03-04 18:16:49 +00:00
for (i = 0; i < v2->items; i++)
Vector_add(this, v2->array[i]);
2006-03-04 18:16:49 +00:00
v2->items = 0;
Vector_delete(v2);
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
*/
void Vector_add(Vector* this, void* data_) {
2006-03-04 18:16:49 +00:00
Object* data = data_;
assert(Object_isA(data, this->type));
assert(Vector_isConsistent(this));
2006-11-12 21:52:14 +00:00
int i = this->items;
Vector_set(this, this->items, data);
2006-11-12 21:52:14 +00:00
assert(this->items == i+1); (void)(i);
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
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)
2006-03-04 18:16:49 +00:00
return i;
}
return -1;
}
void Vector_splice(Vector* this, Vector* from) {
assert(Vector_isConsistent(this));
assert(Vector_isConsistent(from));
assert(!(this->owner && from->owner));
2020-10-02 12:33:07 +00:00
int olditems = this->items;
this->items += from->items;
Vector_checkArraySize(this);
for (int j = 0; j < from->items; j++)
2020-10-02 12:33:07 +00:00
this->array[olditems + j] = from->array[j];
}