htop/Vector.c

256 lines
6.2 KiB
C
Raw Normal View History

2006-03-04 18:16:49 +00:00
/*
htop
2010-02-25 02:08:18 +00:00
(C) 2004-2010 Hisham H. Muhammad
2006-03-04 18:16:49 +00:00
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
#include "Vector.h"
2006-03-04 18:16:49 +00:00
#include "Object.h"
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "debug.h"
#include <assert.h>
/*{
#ifndef DEFAULT_SIZE
#define DEFAULT_SIZE -1
#endif
typedef struct Vector_ {
2006-03-04 18:16:49 +00:00
Object **array;
Object_Compare compare;
2006-03-04 18:16:49 +00:00
int arraySize;
int growthRate;
int items;
char* vectorType;
bool owner;
} Vector;
2006-03-04 18:16:49 +00:00
}*/
Vector* Vector_new(char* vectorType_, bool owner, int size, Object_Compare compare) {
Vector* this;
2006-03-04 18:16:49 +00:00
if (size == DEFAULT_SIZE)
size = 10;
this = (Vector*) malloc(sizeof(Vector));
2006-03-04 18:16:49 +00:00
this->growthRate = size;
this->array = (Object**) calloc(size, sizeof(Object*));
this->arraySize = size;
this->items = 0;
this->vectorType = vectorType_;
this->owner = owner;
this->compare = compare;
2006-03-04 18:16:49 +00:00
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])
(this->array[i])->delete(this->array[i]);
}
free(this->array);
free(this);
}
#ifdef DEBUG
static inline bool Vector_isConsistent(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] && this->array[i]->class != this->vectorType)
return false;
return true;
} else {
return true;
}
}
2006-11-12 21:52:14 +00:00
int Vector_count(Vector* this) {
int items = 0;
for (int i = 0; i < this->items; i++) {
if (this->array[i])
items++;
}
assert(items == this->items);
return items;
}
#endif
void Vector_prune(Vector* this) {
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
int i;
for (i = 0; i < this->items; i++)
if (this->array[i]) {
if (this->owner)
(this->array[i])->delete(this->array[i]);
this->array[i] = NULL;
}
this->items = 0;
}
void Vector_sort(Vector* this) {
assert(this->compare);
assert(Vector_isConsistent(this));
Object_Compare compare = this->compare;
/* Insertion sort works best on mostly-sorted arrays. */
for (int i = 1; i < this->items; i++) {
int j;
2006-03-04 18:16:49 +00:00
void* t = this->array[i];
for (j = i-1; j >= 0 && compare(this->array[j], t) > 0; j--)
2006-03-04 18:16:49 +00:00
this->array[j+1] = this->array[j];
this->array[j+1] = t;
}
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;
this->arraySize = this->items + this->growthRate;
this->array = (Object**) realloc(this->array, sizeof(Object*) * this->arraySize);
for (; i < this->arraySize; i++)
this->array[i] = NULL;
}
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_) {
assert(idx >= 0);
2006-03-04 18:16:49 +00:00
assert(((Object*)data_)->class == this->vectorType);
Object* data = data_;
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
Vector_checkArraySize(this);
2006-03-04 18:16:49 +00:00
assert(this->array[this->items] == NULL);
2010-02-25 01:43:18 +00:00
for (int i = this->items; i >= idx; i--) {
2006-03-04 18:16:49 +00:00
this->array[i+1] = this->array[i];
}
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];
2006-03-04 18:16:49 +00:00
assert (removed != NULL);
this->items--;
2010-02-25 01:43:18 +00:00
for (int i = idx; i < this->items; i++)
2006-03-04 18:16:49 +00:00
this->array[i] = this->array[i+1];
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) {
removed->delete(removed);
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_) {
assert(idx >= 0);
2006-03-04 18:16:49 +00:00
assert(((Object*)data_)->class == this->vectorType);
Object* data = data_;
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) {
removed->delete(removed);
}
}
}
2010-02-25 01:43:18 +00:00
this->array[idx] = data;
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:43:18 +00:00
inline Object* Vector_get(Vector* this, int idx) {
assert(idx < this->items);
assert(Vector_isConsistent(this));
2010-02-25 01:43:18 +00:00
return this->array[idx];
2006-03-04 18:16:49 +00:00
}
inline int Vector_size(Vector* this) {
assert(Vector_isConsistent(this));
2006-03-04 18:16:49 +00:00
return this->items;
}
/*
static void Vector_merge(Vector* this, Vector* v2) {
2006-03-04 18:16:49 +00:00
int i;
assert(Vector_isConsistent(this));
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
assert(data_ && ((Object*)data_)->class == this->vectorType);
Object* data = data_;
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
}
inline int Vector_indexOf(Vector* this, void* search_, Object_Compare compare) {
2006-03-04 18:16:49 +00:00
assert(((Object*)search_)->class == this->vectorType);
assert(this->compare);
2006-03-04 18:16:49 +00:00
Object* search = search_;
assert(Vector_isConsistent(this));
for (int i = 0; i < this->items; i++) {
2006-03-04 18:16:49 +00:00
Object* o = (Object*)this->array[i];
if (o && compare(search, o) == 0)
2006-03-04 18:16:49 +00:00
return i;
}
return -1;
}