Skip to content

Commit e3d9f99

Browse files
7bitcoder7bitcoder
committed
improve array / vector code + refactor
1 parent 6718959 commit e3d9f99

File tree

6 files changed

+441
-117
lines changed

6 files changed

+441
-117
lines changed

‎Source/Library/Array.c

Lines changed: 62 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,14 @@
55

66
struct array
77
{
8-
size_t size;
9-
uint8_t sizeOfType;
8+
size_t length;
9+
uint8_t itemSize;
1010
void *data;
1111
};
1212

13-
array *array_create(size_t size, size_t sizeOfType)
13+
array *array_create(size_t length, size_t itemSize)
1414
{
15-
if (size == 0 || sizeOfType == 0)
15+
if (length == 0 || itemSize == 0)
1616
{
1717
return NULL;
1818
}
@@ -21,80 +21,111 @@ array *array_create(size_t size, size_t sizeOfType)
2121
{
2222
return NULL;
2323
}
24-
arr->data = calloc(size, sizeOfType);
24+
arr->data = calloc(length, itemSize);
2525
if (arr->data == NULL)
2626
{
2727
free(arr);
2828
return NULL;
2929
}
30-
arr->size = size;
31-
arr->sizeOfType = sizeOfType;
30+
arr->length = length;
31+
arr->itemSize = itemSize;
3232
return arr;
3333
}
3434

35+
array *array_clone(array *arrayToClone)
36+
{
37+
array *newArray = array_create(array_length(arrayToClone), array_item_size(arrayToClone));
38+
if (newArray == NULL || !array_copy(newArray, arrayToClone, array_length(arrayToClone)))
39+
{
40+
return NULL;
41+
}
42+
return newArray;
43+
}
44+
45+
array *array_from_data(void *data, size_t length, size_t itemSize)
46+
{
47+
array *newArray = array_create(length, itemSize);
48+
if (newArray == NULL || !array_copy_data(newArray, data, length))
49+
{
50+
return NULL;
51+
}
52+
return newArray;
53+
}
54+
55+
bool array_copy(array *destination, array *source, size_t length)
56+
{
57+
size_t sourceLen = array_length(source), sourceItemSize = array_item_size(source);
58+
size_t destLen = array_length(destination), destItemSize = array_item_size(destination);
59+
if (sourceItemSize != destItemSize || length > sourceLen || sourceLen > destLen)
60+
{
61+
return false;
62+
}
63+
return array_copy_data(destination, array_data(source), length);
64+
}
65+
66+
bool array_copy_data(array *destination, void *source, size_t length)
67+
{
68+
memcpy(array_data(destination), source, length * array_item_size(destination));
69+
return true;
70+
}
71+
3572
void *array_at(array *array, size_t index)
3673
{
37-
if (index >= array_size(array))
74+
if (index >= array_length(array))
3875
{
3976
return NULL;
4077
}
41-
uint8_t *casted = (uint8_t *)array->data;
42-
uint8_t *ptr = casted + index * array_size_of_type(array);
78+
uint8_t *casted = (uint8_t *)array_data(array);
79+
uint8_t *ptr = casted + index * array_item_size(array);
4380
return (void *)ptr;
4481
}
4582

46-
bool array_get_at(array *array, size_t index, void *value)
83+
bool array_get_at(array *array, size_t index, void *item)
4784
{
4885
void *ptr = array_at(array, index);
49-
if (ptr == NULL || value == NULL)
86+
if (ptr == NULL || item == NULL)
5087
{
5188
return false;
5289
}
53-
memcpy(value, ptr, array_size_of_type(array));
90+
memcpy(item, ptr, array_item_size(array));
5491
return true;
5592
}
5693

57-
bool array_set_at(array *array, size_t index, void *value)
94+
bool array_set_at(array *array, size_t index, void *item)
5895
{
5996
void *ptr = array_at(array, index);
60-
if (ptr == NULL || value == NULL)
97+
if (ptr == NULL || item == NULL)
6198
{
6299
return false;
63100
}
64-
memcpy(ptr, value, array_size_of_type(array));
101+
memcpy(ptr, item, array_item_size(array));
65102
return true;
66103
}
67104

68105
void *array_front(array *array) { return array_at(array, 0); }
69106

70-
bool array_set_front(array *array, void *value) { return array_set_at(array, 0, value); }
71-
72-
bool array_get_front(array *array, void *value) { return array_get_at(array, 0, value); }
73-
74-
void *array_back(array *array) { return array_at(array, array_size(array) - 1); }
107+
bool array_get_front(array *array, void *item) { return array_get_at(array, 0, item); }
75108

76-
bool array_set_back(array *array, void *value) { return array_set_at(array, array_size(array) - 1, value); }
109+
bool array_set_front(array *array, void *item) { return array_set_at(array, 0, item); }
77110

78-
bool array_get_back(array *array, void *value) { return array_get_at(array, array_size(array) - 1, value); }
111+
void *array_back(array *array) { return array_at(array, array_length(array) - 1); }
79112

80-
size_t array_size(array *array) { return array->size; }
113+
bool array_get_back(array *array, void *item) { return array_get_at(array, array_length(array) - 1, item); }
81114

82-
size_t array_size_of_type(array *array) { return array->sizeOfType; }
115+
bool array_set_back(array *array, void *item) { return array_set_at(array, array_length(array) - 1, item); }
83116

84117
void *array_data(array *array) { return array->data; }
85118

86-
void array_copy(array *source, array *destination)
87-
{
88-
size_t bytes = array_size(source) * array_size_of_type(source);
89-
memcpy(array_data(destination), array_data(source), bytes);
90-
}
119+
size_t array_length(array *array) { return array->length; }
120+
121+
size_t array_item_size(array *array) { return array->itemSize; }
91122

92123
void array_destroy(array *array)
93124
{
94125
if (array == NULL)
95126
{
96127
return;
97128
}
98-
free(array->data);
129+
free(array_data(array));
99130
free(array);
100131
}

‎Source/Library/Vector.c

Lines changed: 94 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,18 @@
11
#include <stdint.h>
22
#include <stdlib.h>
33

4-
#include "Array.h"
54
#include "Vector.h"
65

76
struct vector
87
{
9-
size_t size;
8+
size_t length;
109
array *array;
1110
};
1211

13-
size_t get_array_size(size_t vectorSize)
12+
// private methods
13+
array *vector_array(vector *vector);
14+
15+
size_t get_computed_array_length(size_t vectorSize)
1416
{
1517
if (vectorSize < 5)
1618
{
@@ -19,105 +21,167 @@ size_t get_array_size(size_t vectorSize)
1921
return vectorSize + 10;
2022
}
2123

22-
vector *vector_create(size_t size, size_t sizeOfType)
24+
// public implementation
25+
vector *vector_create(size_t length, size_t itemSize)
2326
{
2427
vector *vec = (vector *)malloc(sizeof(vector));
2528
if (vec == NULL)
2629
{
2730
return NULL;
2831
}
2932

30-
array *array = array_create(get_array_size(size), sizeOfType);
33+
array *array = array_create(get_computed_array_length(length), itemSize);
3134
if (array == NULL)
3235
{
3336
free(vec);
3437
return NULL;
3538
}
36-
vec->size = size;
39+
vec->length = length;
3740
vec->array = array;
3841
return vec;
3942
}
4043

41-
void *vector_at(vector *vector, size_t index)
44+
vector *vector_clone(vector *vectorToClone)
4245
{
43-
if (index >= vector_size(vector))
46+
vector *vec = vector_create(vector_length(vectorToClone), vector_item_size(vectorToClone));
47+
if (vec == NULL || !vector_copy(vec, vectorToClone, vector_length(vectorToClone)))
4448
{
4549
return NULL;
4650
}
47-
return array_at(vector->array, index);
51+
vec->length = vector_length(vectorToClone);
52+
return vec;
4853
}
4954

50-
bool vector_set_at(vector *vector, size_t index, void *value)
55+
vector *vector_from_array(array *array)
56+
{
57+
vector *vec = vector_create(array_length(array), array_item_size(array));
58+
if (vec == NULL || !vector_copy_array(vec, array, array_length(array)))
59+
{
60+
return NULL;
61+
}
62+
return vec;
63+
}
64+
65+
vector *vector_from_data(void *data, size_t length, size_t itemSize)
66+
{
67+
vector *vec = vector_create(length, itemSize);
68+
if (vec == NULL || !vector_copy_data(vec, data, length))
69+
{
70+
return NULL;
71+
}
72+
return vec;
73+
}
74+
75+
bool vector_copy(vector *destination, vector *source, size_t length)
5176
{
52-
if (index >= vector_size(vector))
77+
size_t sourceLen = vector_length(source), sourceItemSize = vector_item_size(source);
78+
size_t destLen = vector_length(destination), destItemSize = vector_item_size(destination);
79+
if (sourceItemSize != destItemSize || length > sourceLen || sourceLen > destLen)
5380
{
5481
return false;
5582
}
56-
return array_set_at(vector->array, index, value);
83+
84+
return vector_copy_array(destination, vector_array(source), length);
85+
}
86+
87+
bool vector_copy_array(vector *destination, array *source, size_t length)
88+
{
89+
return array_copy(vector_array(destination), source, length);
90+
}
91+
92+
bool vector_copy_data(vector *destination, void *source, size_t length)
93+
{
94+
return array_copy_data(vector_array(destination), source, length);
95+
}
96+
97+
void *vector_at(vector *vector, size_t index)
98+
{
99+
if (index >= vector_length(vector))
100+
{
101+
return NULL;
102+
}
103+
return array_at(vector->array, index);
57104
}
58105

59106
bool vector_get_at(vector *vector, size_t index, void *value)
60107
{
61-
if (index >= vector_size(vector))
108+
if (index >= vector_length(vector))
62109
{
63110
return false;
64111
}
65112
return array_get_at(vector->array, index, value);
66113
}
67114

68-
void *vector_front(vector *vector) { return vector_at(vector, 0); }
115+
bool vector_set_at(vector *vector, size_t index, void *value)
116+
{
117+
if (index >= vector_length(vector))
118+
{
119+
return false;
120+
}
121+
return array_set_at(vector->array, index, value);
122+
}
69123

70-
bool vector_set_front(vector *vector, void *value) { return vector_set_at(vector, 0, value); }
124+
void *vector_front(vector *vector) { return vector_at(vector, 0); }
71125

72126
bool vector_get_front(vector *vector, void *value) { return vector_get_at(vector, 0, value); }
73127

74-
void *vector_back(vector *vector) { return vector_at(vector, vector_size(vector) - 1); }
128+
bool vector_set_front(vector *vector, void *value) { return vector_set_at(vector, 0, value); }
129+
130+
void *vector_back(vector *vector) { return vector_at(vector, vector_length(vector) - 1); }
75131

76-
bool vector_set_back(vector *vector, void *value) { return vector_set_at(vector, vector_size(vector) - 1, value); }
132+
bool vector_get_back(vector *vector, void *value) { return vector_get_at(vector, vector_length(vector) - 1, value); }
77133

78-
bool vector_get_back(vector *vector, void *value) { return vector_get_at(vector, vector_size(vector) - 1, value); }
134+
bool vector_set_back(vector *vector, void *value) { return vector_set_at(vector, vector_length(vector) - 1, value); }
79135

80136
void *vector_data(vector *vector) { return array_data(vector->array); }
81137

82-
size_t vector_size(vector *vector) { return vector->size; }
138+
size_t vector_length(vector *vector) { return vector->length; }
139+
140+
size_t vector_capacity(vector *vector) { return array_length(vector->array); }
83141

84-
bool vector_empty(vector *vector) { return vector_size(vector) == 0; }
142+
size_t vector_item_size(vector *vector) { return array_item_size(vector->array); }
143+
144+
array *vector_array(vector *vector) { return vector->array; }
145+
146+
bool vector_empty(vector *vector) { return vector_length(vector) == 0; }
85147

86148
bool vector_append(vector *vector, void *value)
87149
{
88-
if (vector_size(vector) < array_size(vector->array))
150+
size_t currentLen = vector_length(vector);
151+
if (currentLen < vector_capacity(vector))
89152
{
90-
vector->size++;
153+
vector->length++;
91154
return vector_set_back(vector, value);
92155
}
93-
size_t newArraySize = get_array_size(vector->size + 1);
156+
size_t newArraySize = get_computed_array_length(currentLen + 1);
94157

95-
array *newArray = array_create(newArraySize, array_size_of_type(vector->array));
158+
array *newArray = array_create(newArraySize, vector_item_size(vector));
96159
if (newArray == NULL)
97160
{
98161
return false;
99162
}
100163

101-
array_copy(vector->array, newArray);
102-
array_destroy(vector->array);
164+
array *oldArray = vector_array(vector);
103165
vector->array = newArray;
104-
vector->size++;
166+
vector->length++;
167+
vector_copy_array(vector, oldArray, currentLen);
168+
array_destroy(oldArray);
105169
return vector_set_back(vector, value);
106170
}
107171

108172
bool vector_pop(vector *vector, void *value)
109173
{
110174
bool result = vector_get_back(vector, value);
111-
if (result && vector->size > 0)
175+
if (result && vector->length > 0)
112176
{
113-
vector->size--;
177+
vector->length--;
114178
}
115179
return result;
116180
}
117181

118182
void vector_erase(vector *vector, size_t index) {}
119183

120-
void vector_clear(vector *vector) { vector->size = 0; }
184+
void vector_clear(vector *vector) { vector->length = 0; }
121185

122186
void vector_destroy(vector *vector)
123187
{

0 commit comments

Comments
 (0)