archeus/src/std/vector.c

#include "arc/std/vector.h"

#include "arc/std/errno.h"
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

struct ARC_Vector {
    uint32_t currentSize, capacity;
    void **data;
};

void ARC_Vector_Create(ARC_Vector **vector){
    *vector = (ARC_Vector *) malloc(sizeof(ARC_Vector));
    (*vector)->currentSize = 0;
    (*vector)->capacity    = 1;
    (*vector)->data        = (void **)malloc(sizeof(void   *));
}

void ARC_Vector_Destroy(ARC_Vector *vector){
    free(vector->data);
    free(vector);
}

void ARC_Vector_Add(ARC_Vector *vector, void *data){
    if(vector->currentSize == ~((uint32_t)0)){
        arc_errno = ARC_ERRNO_OVERFLOW;
        return;
    }

    if(vector->currentSize == vector->capacity){
        if(!vector->capacity){
            ++vector->capacity;
        }
        vector->capacity <<= 1;

        vector->data = (void *)realloc(vector->data, sizeof(void *) * vector->capacity);
    }

    vector->data[vector->currentSize] = data;
    ++(vector->currentSize);
}

//this function removes the redundant checking currentSize and index that would happen if ARC_Vector_Remove called ARC_Vector_RemoveIndex
void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t index);

void ARC_Vector_Remove(ARC_Vector *vector, void *data, ARC_Vector_CompareDataFn compare){
    if(!vector->currentSize){
        arc_errno = ARC_ERRNO_DATA;
        return;
    }

    for(uint32_t i = 0; i < vector->currentSize; i++){
        if(!compare(data, vector->data[i])){
            ARC_Vector_RemoveIndexNoCheck(vector, i);
            return;
        }
    }

    //no matching data found in compare function
    arc_errno = ARC_ERRNO_DATA;
}

void ARC_Vector_RemoveIndex(ARC_Vector *vector, uint32_t index){
    if(!vector->currentSize || index >= vector->currentSize){
        arc_errno = ARC_ERRNO_DATA;
        return;
    }

    ARC_Vector_RemoveIndexNoCheck(vector, index);
}

void ARC_Vector_RemoveIndexNoCheck(ARC_Vector *vector, uint32_t index){
    for(uint32_t i = index; i <= vector->currentSize; i++){
        if(i + 1 >= vector->currentSize - 1){
            break;
        }
        vector->data[i] = vector->data[i + 1];
    }

    --vector->currentSize;

    if(vector->currentSize != vector->capacity >> 1){
        return;
    }

    vector->capacity >>= 1;
    if(vector->capacity <= 0){
        vector->capacity = 1;
    }

    vector->data = (void *)realloc(vector->data, sizeof(void *) * vector->capacity);
}

uint32_t ARC_Vector_Size(ARC_Vector *vector){
    return vector->currentSize;
}

void *ARC_Vector_Get(ARC_Vector *vector, uint32_t index){
    if(index >= vector->currentSize){
        return NULL;
    }

    return vector->data[index];
}