cvector_void.c

Go to the documentation of this file.

#include "cvector_void.h"
 
 
 
#if defined(CVEC_MALLOC) && defined(CVEC_FREE) && defined(CVEC_REALLOC)
/* ok */
#elif !defined(CVEC_MALLOC) && !defined(CVEC_FREE) && !defined(CVEC_REALLOC)
/* ok */
#else
#error "Must define all or none of CVEC_MALLOC, CVEC_FREE, and CVEC_REALLOC."
#endif
 
#ifndef CVEC_MALLOC
#define CVEC_MALLOC(sz)      malloc(sz)
#define CVEC_REALLOC(p, sz)  realloc(p, sz)
#define CVEC_FREE(p)         free(p)
#endif
 
#ifndef CVEC_MEMMOVE
#include <string.h>
#define CVEC_MEMMOVE(dst, src, sz)  memmove(dst, src, sz)
#endif
 
#ifndef CVEC_ASSERT
#include <assert.h>
#define CVEC_ASSERT(x)       assert(x)
#endif
 
cvec_sz CVEC_VOID_START_SZ = 20;
 
#define CVEC_VOID_ALLOCATOR(x) ((x+1) * 2)
 
cvector_void* cvec_void_heap(cvec_sz size, cvec_sz capacity, cvec_sz elem_sz, void(*elem_free)(void*), int(*elem_init)(void*, void*))
{
    cvector_void* vec;
    if (!(vec = (cvector_void*)CVEC_MALLOC(sizeof(cvector_void)))) {
        CVEC_ASSERT(vec != NULL);
        return NULL;
    }
 
    vec->size = size;
    vec->capacity = (capacity > vec->size || (vec->size && capacity == vec->size)) ? capacity : vec->size + CVEC_VOID_START_SZ;
 
    vec->elem_size = elem_sz;
    
    if (!(vec->a = (cvec_u8*)CVEC_MALLOC(vec->capacity*elem_sz))) {
        CVEC_ASSERT(vec->a != NULL);
        CVEC_FREE(vec);
        return NULL;
    }
    /* not clearing to 0 here as in cvector_str because elem_free cannot be calling CVEC_FREE directly
     * since it takes the address of the element not the element itself */
 
    vec->elem_free = elem_free;
    vec->elem_init = elem_init;
 
    return vec;
}
 
cvector_void* cvec_init_void_heap(void* vals, cvec_sz num, cvec_sz elem_sz, void(*elem_free)(void*), int(*elem_init)(void*, void*))
{
    cvector_void* vec;
    cvec_sz i;
    
    if (!(vec = (cvector_void*)CVEC_MALLOC(sizeof(cvector_void)))) {
        CVEC_ASSERT(vec != NULL);
        return NULL;
    }
 
    vec->elem_size = elem_sz;
 
    vec->capacity = num + CVEC_VOID_START_SZ;
    vec->size = num;
    if (!(vec->a = (cvec_u8*)CVEC_MALLOC(vec->capacity*elem_sz))) {
        CVEC_ASSERT(vec->a != NULL);
        CVEC_FREE(vec);
        return NULL;
    }
 
    if (elem_init) {
        for (i=0; i<num; ++i) {
            if (!elem_init(&vec->a[i*elem_sz], &((cvec_u8*)vals)[i*elem_sz])) {
                CVEC_ASSERT(0);
                CVEC_FREE(vec->a);
                CVEC_FREE(vec);
                return NULL;
            }
        }
    } else {
        CVEC_MEMMOVE(vec->a, vals, elem_sz*num);
    }
    
    vec->elem_free = elem_free;
    vec->elem_init = elem_init;
 
    return vec;
}
 
int cvec_void(cvector_void* vec, cvec_sz size, cvec_sz capacity, cvec_sz elem_sz, void(*elem_free)(void*), int(*elem_init)(void*, void*))
{
    vec->size = size;
    vec->capacity = (capacity > vec->size || (vec->size && capacity == vec->size)) ? capacity : vec->size + CVEC_VOID_START_SZ;
 
    vec->elem_size = elem_sz;
    
    if (!(vec->a = (cvec_u8*)CVEC_MALLOC(vec->capacity*elem_sz))) {
        CVEC_ASSERT(vec->a != NULL);
        vec->size = vec->capacity = 0;
        return 0;
    }
 
    vec->elem_free = elem_free;
    vec->elem_init = elem_init;
 
    return 1;
}
 
int cvec_init_void(cvector_void* vec, void* vals, cvec_sz num, cvec_sz elem_sz, void(*elem_free)(void*), int(*elem_init)(void*, void*))
{
    cvec_sz i;
    
    vec->elem_size = elem_sz;
 
    vec->capacity = num + CVEC_VOID_START_SZ;
    vec->size = num;
    if (!(vec->a = (cvec_u8*)CVEC_MALLOC(vec->capacity*elem_sz))) {
        CVEC_ASSERT(vec->a != NULL);
        vec->size = vec->capacity = 0;
        return 0;
    }
 
    if (elem_init) {
        for (i=0; i<num; ++i) {
            if (!elem_init(&vec->a[i*elem_sz], &((cvec_u8*)vals)[i*elem_sz])) {
                CVEC_ASSERT(0);
                return 0;
            }
        }
    } else {
        CVEC_MEMMOVE(vec->a, vals, elem_sz*num);
    }
 
    vec->elem_free = elem_free;
    vec->elem_init = elem_init;
 
    return 1;
}
 
int cvec_copyc_void(void* dest, void* src)
{
    cvector_void* vec1 = (cvector_void*)dest;
    cvector_void* vec2 = (cvector_void*)src;
 
    vec1->a = NULL;
    vec1->size = 0;
    vec1->capacity = 0;
 
    return cvec_copy_void(vec1, vec2);
}
 
int cvec_copy_void(cvector_void* dest, cvector_void* src)
{
    int i;
    cvec_u8* tmp = NULL;
    if (!(tmp = (cvec_u8*)CVEC_REALLOC(dest->a, src->capacity*src->elem_size))) {
        CVEC_ASSERT(tmp != NULL);
        return 0;
    }
    dest->a = tmp;
 
    if (src->elem_init) {
        for (i=0; i<src->size; ++i) {
            if (!src->elem_init(&dest->a[i*src->elem_size], &src->a[i*src->elem_size])) {
                CVEC_ASSERT(0);
                return 0;
            }
        }
    } else {
        /* could use memcpy here since we know we just allocated dest->a */
        CVEC_MEMMOVE(dest->a, src->a, src->size*src->elem_size);
    }
 
    dest->size = src->size;
    dest->capacity = src->capacity;
    dest->elem_size = src->elem_size;
    dest->elem_free = src->elem_free;
    dest->elem_init = src->elem_init;
    return 1;
}
 
int cvec_push_void(cvector_void* vec, void* a)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity == vec->size) {
        tmp_sz = CVEC_VOID_ALLOCATOR(vec->capacity);
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
    if (vec->elem_init) {
        if (!vec->elem_init(&vec->a[vec->size*vec->elem_size], a)) {
            CVEC_ASSERT(0);
            return 0;
        }
    } else {
        CVEC_MEMMOVE(&vec->a[vec->size*vec->elem_size], a, vec->elem_size);
    }
    
    vec->size++;
    return 1;
}
 
int cvec_pushm_void(cvector_void* vec, void* a)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity == vec->size) {
        tmp_sz = CVEC_VOID_ALLOCATOR(vec->capacity);
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
    CVEC_MEMMOVE(&vec->a[vec->size*vec->elem_size], a, vec->elem_size);
    
    vec->size++;
    return 1;
}
 
 
void cvec_pop_void(cvector_void* vec, void* ret)
{
    vec->size--;
    if (ret) {
        CVEC_MEMMOVE(ret, &vec->a[vec->size*vec->elem_size], vec->elem_size);
    }
    if (vec->elem_free) {
        vec->elem_free(&vec->a[vec->size*vec->elem_size]);
    }
}
 
void cvec_popm_void(cvector_void* vec, void* ret)
{
    vec->size--;
    if (ret) {
        CVEC_MEMMOVE(ret, &vec->a[vec->size*vec->elem_size], vec->elem_size);
    }
}
 
void* cvec_back_void(cvector_void* vec)
{
    return &vec->a[(vec->size-1)*vec->elem_size];
}
 
int cvec_extend_void(cvector_void* vec, cvec_sz num)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity < vec->size + num) {
        tmp_sz = vec->capacity + num + CVEC_VOID_START_SZ;
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
 
    vec->size += num;
    return 1;
}
 
void* cvec_get_void(cvector_void* vec, cvec_sz i)
{
    return &vec->a[i*vec->elem_size];
}
 
int cvec_insert_void(cvector_void* vec, cvec_sz i, void* a)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity == vec->size) {
        tmp_sz = CVEC_VOID_ALLOCATOR(vec->capacity);
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
    CVEC_MEMMOVE(&vec->a[(i+1)*vec->elem_size], &vec->a[i*vec->elem_size], (vec->size-i)*vec->elem_size);
 
    if (vec->elem_init) {
        if (!vec->elem_init(&vec->a[i*vec->elem_size], a)) {
            CVEC_ASSERT(0);
            return 0;
        }
    } else {
        CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, vec->elem_size);
    }
 
    vec->size++;
    return 1;
}
 
int cvec_insertm_void(cvector_void* vec, cvec_sz i, void* a)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity == vec->size) {
        tmp_sz = CVEC_VOID_ALLOCATOR(vec->capacity);
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
    CVEC_MEMMOVE(&vec->a[(i+1)*vec->elem_size], &vec->a[i*vec->elem_size], (vec->size-i)*vec->elem_size);
 
    CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, vec->elem_size);
 
    vec->size++;
    return 1;
}
 
int cvec_insert_array_void(cvector_void* vec, cvec_sz i, void* a, cvec_sz num)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz, j;
    if (vec->capacity < vec->size + num) {
        tmp_sz = vec->capacity + num + CVEC_VOID_START_SZ;
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
 
    CVEC_MEMMOVE(&vec->a[(i+num)*vec->elem_size], &vec->a[i*vec->elem_size], (vec->size-i)*vec->elem_size);
    if (vec->elem_init) {
        for (j=0; j<num; ++j) {
            if (!vec->elem_init(&vec->a[(j+i)*vec->elem_size], &((cvec_u8*)a)[j*vec->elem_size])) {
                CVEC_ASSERT(0);
                return 0;
            }
        }
    } else {
        CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, num*vec->elem_size);
    }
    vec->size += num;
    return 1;
}
 
int cvec_insert_arraym_void(cvector_void* vec, cvec_sz i, void* a, cvec_sz num)
{
    cvec_u8* tmp;
    cvec_sz tmp_sz;
    if (vec->capacity < vec->size + num) {
        tmp_sz = vec->capacity + num + CVEC_VOID_START_SZ;
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*tmp_sz))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = tmp_sz;
    }
 
    CVEC_MEMMOVE(&vec->a[(i+num)*vec->elem_size], &vec->a[i*vec->elem_size], (vec->size-i)*vec->elem_size);
 
    CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, num*vec->elem_size);
    vec->size += num;
    return 1;
}
 
int cvec_replace_void(cvector_void* vec, cvec_sz i, void* a, void* ret)
{
    if (ret) {
        CVEC_MEMMOVE(ret, &vec->a[i*vec->elem_size], vec->elem_size);
    } else if (vec->elem_free) {
        vec->elem_free(&vec->a[i*vec->elem_size]);
    }
 
    if (vec->elem_init) {
        if (!vec->elem_init(&vec->a[i*vec->elem_size], a)) {
            CVEC_ASSERT(0);
            return 0;
        }
    } else {
        CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, vec->elem_size);
    }
    return 1;
}
 
void cvec_replacem_void(cvector_void* vec, cvec_sz i, void* a, void* ret)
{
    if (ret) {
        CVEC_MEMMOVE(ret, &vec->a[i*vec->elem_size], vec->elem_size);
    }
 
    CVEC_MEMMOVE(&vec->a[i*vec->elem_size], a, vec->elem_size);
}
 
void cvec_erase_void(cvector_void* vec, cvec_sz start, cvec_sz end)
{
    cvec_sz i;
    cvec_sz d = end - start + 1;
    if (vec->elem_free) {
        for (i=start; i<=end; i++) {
            vec->elem_free(&vec->a[i*vec->elem_size]);
        }
    }
    CVEC_MEMMOVE(&vec->a[start*vec->elem_size], &vec->a[(end+1)*vec->elem_size], (vec->size-1-end)*vec->elem_size);
    vec->size -= d;
}
 
void cvec_remove_void(cvector_void* vec, cvec_sz start, cvec_sz end)
{
    cvec_sz d = end - start + 1;
    CVEC_MEMMOVE(&vec->a[start*vec->elem_size], &vec->a[(end+1)*vec->elem_size], (vec->size-1-end)*vec->elem_size);
    vec->size -= d;
}
 
int cvec_reserve_void(cvector_void* vec, cvec_sz size)
{
    cvec_u8* tmp;
    if (vec->capacity < size) {
        if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*(size+CVEC_VOID_START_SZ)))) {
            CVEC_ASSERT(tmp != NULL);
            return 0;
        }
        vec->a = tmp;
        vec->capacity = size + CVEC_VOID_START_SZ;
    }
    return 1;
}
 
int cvec_set_cap_void(cvector_void* vec, cvec_sz size)
{
    cvec_sz i;
    cvec_u8* tmp;
    if (size < vec->size) {
        if (vec->elem_free) {
            for (i=vec->size-1; i>=size; i--) {
                vec->elem_free(&vec->a[i*vec->elem_size]);
            }
        }
        vec->size = size;
    }
 
    vec->capacity = size;
 
    if (!(tmp = (cvec_u8*)CVEC_REALLOC(vec->a, vec->elem_size*size))) {
        CVEC_ASSERT(tmp != NULL);
        return 0;
    }
    vec-> a = tmp;
    return 1;
}
 
int cvec_set_val_sz_void(cvector_void* vec, void* val)
{
    cvec_sz i;
 
    if (vec->elem_free) {
        for(i=0; i<vec->size; i++) {
            vec->elem_free(&vec->a[i*vec->elem_size]);
        }
    }
    
    if (vec->elem_init) {
        for (i=0; i<vec->size; i++) {
            if (!vec->elem_init(&vec->a[i*vec->elem_size], val)) {
                CVEC_ASSERT(0);
                return 0;
            }
        }
    } else {
        for (i=0; i<vec->size; i++) {
            CVEC_MEMMOVE(&vec->a[i*vec->elem_size], val, vec->elem_size);
        }
    }
    return 1;
}
 
int cvec_set_val_cap_void(cvector_void* vec, void* val)
{
    cvec_sz i;
    if (vec->elem_free) {
        for (i=0; i<vec->size; i++) {
            vec->elem_free(&vec->a[i*vec->elem_size]);
        }
        vec->size = vec->capacity;
    }
 
    if (vec->elem_init) {
        for (i=0; i<vec->capacity; i++) {
            if (!vec->elem_init(&vec->a[i*vec->elem_size], val)) {
                CVEC_ASSERT(0);
                return 0;
            }
        }
    } else {
        for (i=0; i<vec->capacity; i++) {
            CVEC_MEMMOVE(&vec->a[i*vec->elem_size], val, vec->elem_size);
        }
    }
    return 1;
}
 
void cvec_clear_void(cvector_void* vec)
{
    cvec_sz i;
    if (vec->elem_free) {
        for (i=0; i<vec->size; ++i) {
            vec->elem_free(&vec->a[i*vec->elem_size]);
        }
    }
    vec->size = 0;
}
 
void cvec_free_void_heap(void* vec)
{
    cvec_sz i;
    cvector_void* tmp = (cvector_void*)vec;
    if (!tmp) return;
    if (tmp->elem_free) {
        for (i=0; i<tmp->size; i++) {
            tmp->elem_free(&tmp->a[i*tmp->elem_size]);
        }
    }
    CVEC_FREE(tmp->a);
    CVEC_FREE(tmp);
}
 
void cvec_free_void(void* vec)
{
    cvec_sz i;
    cvector_void* tmp = (cvector_void*)vec;
    if (tmp->elem_free) {
        for (i=0; i<tmp->size; i++) {
            tmp->elem_free(&tmp->a[i*tmp->elem_size]);
        }
    }
 
    CVEC_FREE(tmp->a);
 
    tmp->size = 0;
    tmp->capacity = 0;
}