libcutils

libcutils/src/byte_array.c
byte_array.c
⎇
Raw
1#include <cutils/byte_array.h>
2
3Bytearray* bytearray_with_capacity(size_t capacity, size_t element_size)
4{
5 Bytearray* bytearray;
6
7 bytearray = malloc(sizeof(*bytearray));
8 if(!bytearray)
9 return NULL;
10
11 bytearray->items = malloc(sizeof(*bytearray->items)*capacity*element_size);
12 if(!bytearray->items)
13 {
14 free(bytearray);
15 return NULL;
16 }
17
18 bytearray->length = 0;
19 bytearray->capacity = capacity;
20 bytearray->element_size = element_size;
21
22 return bytearray;
23}
24
25
26void delete_bytearray(Bytearray* bytearray, void(*rmv_el) (void*))
27{
28 if(rmv_el)
29 {
30 size_t i;
31 for(i = 0; i < bytearray->length; i++)
32 {
33 rmv_el(&bytearray->items[i*bytearray->element_size]);
34 }
35 }
36
37 free(bytearray->items);
38 free(bytearray);
39}
40
41void* bytearray_at(const Bytearray* bytearray, size_t index)
42{
43 if(index >= bytearray->length)
44 return NULL;
45 else
46 return bytearray->items+(index*bytearray->element_size);
47}
48
49void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr)
50{
51 void *tmp;
52
53 tmp = bytearray_at(bytearray, index);
54 if(!tmp)
55 return NULL;
56
57 retptr = retptr ? retptr : malloc(bytearray->element_size);
58 if(!retptr)
59 return NULL;
60
61 memcpy(retptr, tmp, bytearray->element_size);
62 bytearray_remove(bytearray, index, NULL);
63 return retptr;
64}
65
66bool bytearray_insert(Bytearray* bytearray, size_t index, const void* item)
67{
68 size_t length = bytearray->length;
69 size_t size = bytearray->element_size;
70
71 if(index > length || length == SIZE_MAX || !bytearray_adjust_size(bytearray, length+1))
72 return false;
73
74 memmove(bytearray->items+index*size+1*size, bytearray->items+index*size, (length*size-index*size)*sizeof(*bytearray->items));
75 memcpy(bytearray->items+index*size, item, bytearray->element_size);
76 bytearray->length++;
77 return true;
78}
79
80void bytearray_remove(Bytearray* bytearray, size_t index, void (*rmv)(void*))
81{
82 if(index < bytearray->length)
83 {
84 size_t length = bytearray->length;
85 size_t elsize = bytearray->element_size;
86 if(rmv)
87 rmv(&bytearray->items[index*elsize]);
88
89 memmove(bytearray->items+index*elsize, bytearray->items+index*elsize+1*elsize, length*elsize-index*elsize-1*elsize);
90 bytearray->length--;
91 }
92}
93
94bool bytearray_adjust_size(Bytearray* bytearray, size_t size)
95{
96 while(bytearray->capacity < size)
97 {
98 byte* tmp = bytearray->items;
99 bytearray->items = cutil_reallocarray_inc(bytearray->items, bytearray->capacity, bytearray->element_size, bytearray->capacity);
100 if(!bytearray->items)
101 {
102 bytearray->items = tmp;
103 return false;
104 }
105 bytearray->capacity *= 2;
106 }
107 return true;
108}
109
110bool bytearray_shrink(Bytearray* bytearray)
111{
112 while(bytearray->capacity > bytearray->length*2)
113 {
114 byte* tmp = bytearray->items;
115 bytearray->items = cutil_reallocarray(bytearray->items, bytearray->capacity/2, bytearray->element_size);
116 if(!bytearray->items)
117 {
118 bytearray->items = tmp;
119 return false;
120 }
121 bytearray->capacity /= 2;
122 }
123 return true;
124}
125
126size_t* bytearray_find(const Bytearray* haystack, const void* needle, int (*cmp)(const void*, const void*))
127{
128 size_t* ret;
129 size_t i;
130
131 for(i = 0; i < haystack->length; i++)
132 {
133 if(cmp(haystack->items+(i*haystack->element_size),needle) == 0)
134 {
135 ret = malloc(sizeof(*ret));
136 *ret = i;
137 return ret;
138 }
139 }
140 return NULL;
141}
142