CVector 4.3.0
A C++ style vector library in strict ANSI C (C89)
Loading...
Searching...
No Matches
cvector_i.c
Go to the documentation of this file.
1#include "cvector_i.h"
2
3
4
5#if defined(CVEC_MALLOC) && defined(CVEC_FREE) && defined(CVEC_REALLOC)
6/* ok */
7#elif !defined(CVEC_MALLOC) && !defined(CVEC_FREE) && !defined(CVEC_REALLOC)
8/* ok */
9#else
10#error "Must define all or none of CVEC_MALLOC, CVEC_FREE, and CVEC_REALLOC."
11#endif
12
13#ifndef CVEC_MALLOC
14#include <stdlib.h>
15#define CVEC_MALLOC(sz) malloc(sz)
16#define CVEC_REALLOC(p, sz) realloc(p, sz)
17#define CVEC_FREE(p) free(p)
18#endif
19
20#ifndef CVEC_MEMMOVE
21#include <string.h>
22#define CVEC_MEMMOVE(dst, src, sz) memmove(dst, src, sz)
23#endif
24
25#ifndef CVEC_ASSERT
26#include <assert.h>
27#define CVEC_ASSERT(x) assert(x)
28#endif
29
31
32#define CVEC_I_ALLOCATOR(x) ((x+1) * 2)
33
41{
42 cvector_i* vec;
43 if (!(vec = (cvector_i*)CVEC_MALLOC(sizeof(cvector_i)))) {
44 CVEC_ASSERT(vec != NULL);
45 return NULL;
46 }
47
48 vec->size = size;
49 vec->capacity = (capacity > vec->size || (vec->size && capacity == vec->size)) ? capacity : vec->size + CVEC_I_START_SZ;
50
51 if (!(vec->a = (int*)CVEC_MALLOC(vec->capacity*sizeof(int)))) {
52 CVEC_ASSERT(vec->a != NULL);
53 CVEC_FREE(vec);
54 return NULL;
55 }
56
57 return vec;
58}
59
64{
65 cvector_i* vec;
66
67 if (!(vec = (cvector_i*)CVEC_MALLOC(sizeof(cvector_i)))) {
68 CVEC_ASSERT(vec != NULL);
69 return NULL;
70 }
71
72 vec->capacity = num + CVEC_I_START_SZ;
73 vec->size = num;
74 if (!(vec->a = (int*)CVEC_MALLOC(vec->capacity*sizeof(int)))) {
75 CVEC_ASSERT(vec->a != NULL);
76 CVEC_FREE(vec);
77 return NULL;
78 }
79
80 CVEC_MEMMOVE(vec->a, vals, sizeof(int)*num);
81
82 return vec;
83}
84
89int cvec_i(cvector_i* vec, cvec_sz size, cvec_sz capacity)
90{
91 vec->size = size;
92 vec->capacity = (capacity > vec->size || (vec->size && capacity == vec->size)) ? capacity : vec->size + CVEC_I_START_SZ;
93
94 if (!(vec->a = (int*)CVEC_MALLOC(vec->capacity*sizeof(int)))) {
95 CVEC_ASSERT(vec->a != NULL);
96 vec->size = vec->capacity = 0;
97 return 0;
98 }
99
100 return 1;
101}
102
106int cvec_init_i(cvector_i* vec, int* vals, cvec_sz num)
107{
108 vec->capacity = num + CVEC_I_START_SZ;
109 vec->size = num;
110 if (!(vec->a = (int*)CVEC_MALLOC(vec->capacity*sizeof(int)))) {
111 CVEC_ASSERT(vec->a != NULL);
112 vec->size = vec->capacity = 0;
113 return 0;
114 }
115
116 CVEC_MEMMOVE(vec->a, vals, sizeof(int)*num);
117
118 return 1;
119}
120
131int cvec_copyc_i(void* dest, void* src)
132{
133 cvector_i* vec1 = (cvector_i*)dest;
134 cvector_i* vec2 = (cvector_i*)src;
135
136 vec1->a = NULL;
137 vec1->size = 0;
138 vec1->capacity = 0;
139
140 return cvec_copy_i(vec1, vec2);
141}
142
153{
154 int* tmp = NULL;
155 if (!(tmp = (int*)CVEC_REALLOC(dest->a, src->capacity*sizeof(int)))) {
156 CVEC_ASSERT(tmp != NULL);
157 return 0;
158 }
159 dest->a = tmp;
160
161 CVEC_MEMMOVE(dest->a, src->a, src->size*sizeof(int));
162 dest->size = src->size;
163 dest->capacity = src->capacity;
164 return 1;
165}
166
171int cvec_push_i(cvector_i* vec, int a)
172{
173 int* tmp;
174 cvec_sz tmp_sz;
175 if (vec->capacity == vec->size) {
176 tmp_sz = CVEC_I_ALLOCATOR(vec->capacity);
177 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*tmp_sz))) {
178 CVEC_ASSERT(tmp != NULL);
179 return 0;
180 }
181 vec->a = tmp;
182 vec->capacity = tmp_sz;
183 }
184
185 vec->a[vec->size++] = a;
186 return 1;
187}
188
191{
192 return vec->a[--vec->size];
193}
194
197{
198 return &vec->a[vec->size-1];
199}
200
204{
205 int* tmp;
206 cvec_sz tmp_sz;
207 if (vec->capacity < vec->size + num) {
208 tmp_sz = vec->capacity + num + CVEC_I_START_SZ;
209 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*tmp_sz))) {
210 CVEC_ASSERT(tmp != NULL);
211 return 0;
212 }
213 vec->a = tmp;
214 vec->capacity = tmp_sz;
215 }
216
217 vec->size += num;
218 return 1;
219}
220
225int cvec_insert_i(cvector_i* vec, cvec_sz i, int a)
226{
227 int* tmp;
228 cvec_sz tmp_sz;
229 if (vec->capacity == vec->size) {
230 tmp_sz = CVEC_I_ALLOCATOR(vec->capacity);
231 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*tmp_sz))) {
232 CVEC_ASSERT(tmp != NULL);
233 return 0;
234 }
235 vec->a = tmp;
236 vec->capacity = tmp_sz;
237 }
238
239 CVEC_MEMMOVE(&vec->a[i+1], &vec->a[i], (vec->size-i)*sizeof(int));
240 vec->a[i] = a;
241 vec->size++;
242 return 1;
243}
244
252{
253 int* tmp;
254 cvec_sz tmp_sz;
255 if (vec->capacity < vec->size + num) {
256 tmp_sz = vec->capacity + num + CVEC_I_START_SZ;
257 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*tmp_sz))) {
258 CVEC_ASSERT(tmp != NULL);
259 return 0;
260 }
261 vec->a = tmp;
262 vec->capacity = tmp_sz;
263 }
264
265 CVEC_MEMMOVE(&vec->a[i+num], &vec->a[i], (vec->size-i)*sizeof(int));
266 CVEC_MEMMOVE(&vec->a[i], a, num*sizeof(int));
267 vec->size += num;
268 return 1;
269}
270
273{
274 int tmp = vec->a[i];
275 vec->a[i] = a;
276 return tmp;
277}
278
284void cvec_erase_i(cvector_i* vec, cvec_sz start, cvec_sz end)
285{
286 cvec_sz d = end - start + 1;
287 CVEC_MEMMOVE(&vec->a[start], &vec->a[end+1], (vec->size-1-end)*sizeof(int));
288 vec->size -= d;
289}
290
293{
294 int* tmp;
295 if (vec->capacity < size) {
296 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*(size+CVEC_I_START_SZ)))) {
297 CVEC_ASSERT(tmp != NULL);
298 return 0;
299 }
300 vec->a = tmp;
301 vec->capacity = size + CVEC_I_START_SZ;
302 }
303 return 1;
304}
305
311{
312 int* tmp;
313 if (size < vec->size) {
314 vec->size = size;
315 }
316
317 if (!(tmp = (int*)CVEC_REALLOC(vec->a, sizeof(int)*size))) {
318 CVEC_ASSERT(tmp != NULL);
319 return 0;
320 }
321 vec->a = tmp;
322 vec->capacity = size;
323 return 1;
324}
325
327void cvec_set_val_sz_i(cvector_i* vec, int val)
328{
329 cvec_sz i;
330 for (i=0; i<vec->size; i++) {
331 vec->a[i] = val;
332 }
333}
334
336void cvec_set_val_cap_i(cvector_i* vec, int val)
337{
338 cvec_sz i;
339 for (i=0; i<vec->capacity; i++) {
340 vec->a[i] = val;
341 }
342}
343
345void cvec_clear_i(cvector_i* vec) { vec->size = 0; }
346
349void cvec_free_i_heap(void* vec)
350{
351 cvector_i* tmp = (cvector_i*)vec;
352 if (!tmp) return;
353 CVEC_FREE(tmp->a);
354 CVEC_FREE(tmp);
355}
356
359void cvec_free_i(void* vec)
360{
361 cvector_i* tmp = (cvector_i*)vec;
362 CVEC_FREE(tmp->a);
363 tmp->a = NULL;
364 tmp->size = 0;
365 tmp->capacity = 0;
366}
367
CVEC_SIZE_T cvec_sz
Definition cvector.h:88
#define CVEC_FREE(p)
Definition cvector_i.c:17
#define CVEC_I_ALLOCATOR(x)
Definition cvector_i.c:32
int cvec_insert_i(cvector_i *vec, cvec_sz i, int a)
Insert a at index i (0 based).
Definition cvector_i.c:225
void cvec_free_i_heap(void *vec)
Frees everything so don't use vec after calling this.
Definition cvector_i.c:349
void cvec_free_i(void *vec)
Frees the internal array and zeros out the members to maintain a consistent state.
Definition cvector_i.c:359
#define CVEC_REALLOC(p, sz)
Definition cvector_i.c:16
int cvec_pop_i(cvector_i *vec)
Remove and return the last element (size decreased 1).
Definition cvector_i.c:190
int cvec_copyc_i(void *dest, void *src)
Makes dest a copy of src.
Definition cvector_i.c:131
int cvec_replace_i(cvector_i *vec, cvec_sz i, int a)
Replace value at index i with a, return original value.
Definition cvector_i.c:272
int cvec_insert_array_i(cvector_i *vec, cvec_sz i, int *a, cvec_sz num)
Insert the first num elements of array a at index i.
Definition cvector_i.c:251
cvec_sz CVEC_I_START_SZ
Definition cvector_i.c:30
int cvec_copy_i(cvector_i *dest, cvector_i *src)
Makes dest a copy of src.
Definition cvector_i.c:152
int cvec_set_cap_i(cvector_i *vec, cvec_sz size)
Set capacity to size.
Definition cvector_i.c:310
cvector_i * cvec_init_i_heap(int *vals, cvec_sz num)
Create (on the heap) and initialize cvector_i with num elements of vals.
Definition cvector_i.c:63
#define CVEC_MEMMOVE(dst, src, sz)
Definition cvector_i.c:22
int cvec_reserve_i(cvector_i *vec, cvec_sz size)
Make sure capacity is at least size(parameter not member).
Definition cvector_i.c:292
#define CVEC_MALLOC(sz)
Definition cvector_i.c:15
#define CVEC_ASSERT(x)
Definition cvector_i.c:27
cvector_i * cvec_i_heap(cvec_sz size, cvec_sz capacity)
Creates a new cvector_i on the heap.
Definition cvector_i.c:40
int cvec_push_i(cvector_i *vec, int a)
Append a to end of vector (size increased 1).
Definition cvector_i.c:171
void cvec_erase_i(cvector_i *vec, cvec_sz start, cvec_sz end)
Erases elements from start to end inclusive.
Definition cvector_i.c:284
int cvec_init_i(cvector_i *vec, int *vals, cvec_sz num)
Same as cvec_init_i_heap() except the vector passed in was declared on the stack so it isn't allocate...
Definition cvector_i.c:106
int cvec_i(cvector_i *vec, cvec_sz size, cvec_sz capacity)
Same as cvec_i_heap() except the vector passed in was declared on the stack so it isn't allocated in ...
Definition cvector_i.c:89
void cvec_clear_i(cvector_i *vec)
Sets size to 0 (does not clear contents).
Definition cvector_i.c:345
int cvec_extend_i(cvector_i *vec, cvec_sz num)
Increase the size of the array num items.
Definition cvector_i.c:203
void cvec_set_val_cap_i(cvector_i *vec, int val)
Fills entire allocated array (capacity) with val.
Definition cvector_i.c:336
void cvec_set_val_sz_i(cvector_i *vec, int val)
Set all size elements to val.
Definition cvector_i.c:327
int * cvec_back_i(cvector_i *vec)
Return pointer to last element.
Definition cvector_i.c:196
Data structure for int vector.
Definition cvector.h:101
cvec_sz size
Current size (amount you use when manipulating array directly).
Definition cvector.h:103
int * a
Array.
Definition cvector.h:102
cvec_sz capacity
Allocated size of array; always >= size.
Definition cvector.h:104