src/Vector.c

   1 /**
   2  * @file Vector.cpp
   3  */
   4
   5 #include "cgds/Vector.h"
   6
   7 //////////////////
   8 // Vector logic //
   9 //////////////////
  10
  11 void _vector_init(Vector* vector, size_t dataSize)
  12 {
  13     vector->datas = NULL;
  14     vector->dataSize = dataSize;
  15     vector->size = 0;
  16     vector->capacity = 0;
  17 }
  18
  19 Vector* _vector_new(size_t dataSize)
  20 {
  21     Vector* vector = (Vector*) safe_malloc(sizeof (Vector));
  22     _vector_init(vector, dataSize);
  23     return vector;
  24 }
  25
  26 Vector* vector_copy(Vector* vector)
  27 {
  28     Vector* vectorCopy = _vector_new(vector->dataSize);
  29     vectorCopy->size = vector->size;
  30     vectorCopy->capacity = vector->capacity;
  31     vectorCopy->datas = (void**) safe_malloc(vector->capacity * sizeof (void*));
  32     for (UInt i = 0; i < vector->size; i++)
  33     {
  34         vectorCopy->datas[i] = safe_malloc(vector->dataSize);
  35         memcpy(vectorCopy->datas[i], vector->datas[i], vector->dataSize);
  36     }
  37     return vectorCopy;
  38 }
  39
  40 Bool vector_empty(Vector* vector)
  41 {
  42     return (vector->size == 0);
  43 }
  44
  45 UInt vector_size(Vector* vector)
  46 {
  47     return vector->size;
  48 }
  49
  50 void _vector_realloc(Vector* vector, UInt newCapacity)
  51 {
  52     void** rellocatedDatas = (void**) safe_malloc(newCapacity * sizeof (void*));
  53     for (UInt i = 0; i < vector->size; i++)
  54     {
  55         rellocatedDatas[i] = (void*) safe_malloc(vector->dataSize);
  56         memcpy(rellocatedDatas[i], vector->datas[i], vector->dataSize);
  57         safe_free(vector->datas[i]);
  58     }
  59     safe_free(vector->datas);
  60     vector->datas = rellocatedDatas;
  61     vector->capacity = newCapacity;
  62 }
  63
  64 void _vector_push(Vector* vector, void* data)
  65 {
  66     void* pData = safe_malloc(vector->dataSize);
  67     memcpy(pData, data, vector->dataSize);
  68     if (vector->size >= vector->capacity)
  69     {
  70         UInt increasedCapacity = vector->capacity > 0 ? 2 * vector->capacity : 1;
  71         _vector_realloc(vector, increasedCapacity);
  72     }
  73     vector->datas[vector->size] = pData;
  74     vector->size++;
  75 }
  76
  77 void vector_pop(Vector* vector)
  78 {
  79     safe_free(vector->datas[vector_size(vector) - 1]);
  80     vector->size--;
  81     if (vector_size(vector) <= (vector->capacity >> 1))
  82         _vector_realloc(vector, vector->capacity >> 1);
  83 }
  84
  85 void vector_pop_first(Vector* vector)
  86 {
  87     safe_free(vector->datas[0]);
  88
  89
  90     //HACK: next 3 lines move vector head
  91     void** nextDatas = vector->datas + 1;
  92     safe_free(vector->datas);
  93     vector->datas = nextDatas;
  94 //but memory can then be reallocated : TODO
  95
  96
  97     vector->size--;
  98     if (vector->size <= (vector->capacity >> 1))
  99         _vector_realloc(vector, vector->capacity >> 1);
 100 }
 101
 102 void* _vector_get(Vector* vector, UInt index)
 103 {
 104     return vector->datas[index];
 105 }
 106
 107 void _vector_set(Vector* vector, UInt index, void* data)
 108 {
 109     memcpy(vector->datas[index], data, vector->dataSize);
 110 }
 111
 112 void vector_clear(Vector* vector)
 113 {
 114     for (UInt i = 0; i < vector->size; i++)
 115         safe_free(vector->datas[i]);
 116     safe_free(vector->datas);
 117     _vector_init(vector, vector->dataSize);
 118 }
 119
 120 void vector_destroy(Vector* vector)
 121 {
 122     vector_clear(vector);
 123     safe_free(vector);
 124 }
 125
 126 ////////////////////
 127 // Iterator logic //
 128 ////////////////////
 129
 130 VectorIterator* vector_get_iterator(Vector* vector)
 131 {
 132     VectorIterator* vectorI = (VectorIterator*) safe_malloc(sizeof (VectorIterator));
 133     vectorI->vector = vector;
 134     vectorI_reset_begin(vectorI);
 135     return vectorI;
 136 }
 137
 138 void vectorI_reset_begin(VectorIterator* vectorI)
 139 {
 140     vectorI->current = vectorI->vector->datas;
 141 }
 142
 143 void vectorI_reset_end(VectorIterator* vectorI)
 144 {
 145     vectorI->current = vectorI->vector->datas + vectorI->vector->size - 1;
 146 }
 147
 148 Bool vectorI_has_data(VectorIterator* vectorI)
 149 {
 150     return (vectorI->current >= vectorI->vector->datas &&
 151         vectorI->current < vectorI->vector->datas + vectorI->vector->size);
 152 }
 153
 154 void* _vectorI_get(VectorIterator* vectorI)
 155 {
 156     return *(vectorI->current);
 157 }
 158
 159 void _vectorI_set(VectorIterator* vectorI, void* data)
 160 {
 161     *(vectorI->current) = data;
 162 }
 163
 164 void vectorI_move_next(VectorIterator* vectorI)
 165 {
 166     vectorI->current++;
 167 }
 168
 169 void vectorI_move_prev(VectorIterator* vectorI)
 170 {
 171     vectorI->current--;
 172 }
 173
 174 void vectorI_destroy(VectorIterator* vectorI)
 175 {
 176     safe_free(vectorI);
 177 }