151 lines
3.8 KiB
C
151 lines
3.8 KiB
C
|
|
#include "list.h"
|
|
|
|
#include <malloc.h>
|
|
#include <memory.h>
|
|
#include <errno.h>
|
|
|
|
#define FACTOR 4
|
|
#define meta(ptr) ((list_meta_t *) ((unsigned char *) (ptr) - sizeof(list_meta_t)))
|
|
#define data(ptr) ((unsigned char *) (ptr) + sizeof(list_meta_t))
|
|
|
|
typedef struct {
|
|
int init_size, elem_size, max_size, size;
|
|
} list_meta_t;
|
|
|
|
static void *list_resize(list_meta_t *list, int new_size) {
|
|
if (new_size <= 0) {
|
|
return NULL;
|
|
} else if (new_size == list->max_size) {
|
|
return list;
|
|
}
|
|
|
|
list_meta_t *new_ptr = realloc(list, sizeof(list_meta_t) + list->elem_size * new_size);
|
|
if (new_ptr == NULL)
|
|
return NULL;
|
|
|
|
new_ptr->max_size = new_size;
|
|
return new_ptr;
|
|
}
|
|
|
|
void *list_create(int elem_size, int init_elem_n) {
|
|
if (elem_size <= 0 || init_elem_n <= 0) {
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
|
|
void *list_ptr = malloc(sizeof(list_meta_t) + elem_size * init_elem_n);
|
|
if (list_ptr == NULL)
|
|
return NULL;
|
|
|
|
memset(list_ptr, 0, sizeof(list_meta_t) + elem_size * init_elem_n);
|
|
list_meta_t *list = list_ptr;
|
|
list->init_size = init_elem_n;
|
|
list->elem_size = elem_size;
|
|
list->max_size = init_elem_n;
|
|
list->size = 0;
|
|
return data(list_ptr);
|
|
}
|
|
|
|
int list_size(const void *list_ptr) {
|
|
return meta(list_ptr)->size;
|
|
}
|
|
|
|
int list_find(void *list_ptr, void *elem) {
|
|
list_meta_t *list = meta(list_ptr);
|
|
unsigned char *array = list_ptr;
|
|
|
|
for (int i = 0; i < list->size; i++) {
|
|
if (memcmp(array + i * list->elem_size, elem, list->elem_size) == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int list_contains(void *list_ptr, void *elem) {
|
|
return list_find(list_ptr, elem) != -1;
|
|
}
|
|
|
|
void *list_insert(void *list_ptr, void *elem, int n) {
|
|
void *ptr = NULL;
|
|
list_ptr = list_insert_ptr(list_ptr, &ptr, n);
|
|
if (list_ptr != NULL && ptr != NULL) {
|
|
memcpy(ptr, elem, meta(list_ptr)->elem_size);
|
|
}
|
|
|
|
return list_ptr;
|
|
}
|
|
|
|
void *list_insert_ptr(void *list_ptr, void **elem, int n) {
|
|
list_meta_t *list = meta(list_ptr);
|
|
if (n < 0)
|
|
n = list->size + n + 1;
|
|
|
|
if (list->size >= list->max_size) {
|
|
if ((list = list_resize(list, list->max_size * FACTOR)) == NULL)
|
|
return NULL;
|
|
}
|
|
|
|
unsigned char *array = data(list);
|
|
|
|
if (n < list->size)
|
|
memmove(array + (n + 1) * list->elem_size, array + n * list->elem_size, (list->size - n) * list->elem_size);
|
|
*elem = array + n * list->elem_size;
|
|
memset(*elem, 0, list->elem_size);
|
|
|
|
list->size++;
|
|
return array;
|
|
}
|
|
|
|
void *list_append(void *list_ptr, void *elem) {
|
|
return list_insert(list_ptr, elem, -1);
|
|
}
|
|
|
|
void *list_append_ptr(void *list_ptr, void **elem) {
|
|
return list_insert_ptr(list_ptr, elem, -1);
|
|
}
|
|
|
|
void *list_remove(void *list_ptr, int n) {
|
|
list_meta_t *list = meta(list_ptr);
|
|
if (n < 0)
|
|
n = list->size + n;
|
|
|
|
unsigned char *array = list_ptr;
|
|
|
|
if (list->size > 1 && n < list->size)
|
|
memmove(array + n * list->elem_size, array + (n + 1) * list->elem_size, (list->size - n - 1) * list->elem_size);
|
|
|
|
list->size--;
|
|
memset(array + list->size * list->elem_size, 0, list->elem_size);
|
|
|
|
if (list->size <= list->max_size / FACTOR * 3 / 4 && list->max_size / FACTOR >= list->init_size) {
|
|
if ((list = list_resize(list, list->max_size / FACTOR)) == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return data(list);
|
|
}
|
|
|
|
void *list_delete(void *list_ptr, void *elem) {
|
|
int idx = list_find(list_ptr, elem);
|
|
if (idx == -1) {
|
|
return list_ptr;
|
|
} else {
|
|
return list_remove(list_ptr, idx);
|
|
}
|
|
}
|
|
|
|
void *list_clear(void *list_ptr) {
|
|
list_meta_t *list = meta(list_ptr);
|
|
list->size = 0;
|
|
memset(list_ptr, 0, list->max_size * list->elem_size);
|
|
return data(list_resize(list, list->init_size));
|
|
}
|
|
|
|
void list_free(void *list_ptr) {
|
|
free(meta(list_ptr));
|
|
}
|