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_remove_range(Bytearray* bytearray, size_t index, size_t length, void (*rmv)(void*))
42{
43 size_t i;
44 if(rmv)
45 {
46 for(i = index; i < length; i++)
47 {
48 rmv(bytearray_at(bytearray, i));
49 }
50 }
51 memmove(bytearray->items+index, bytearray->items+index+length, (bytearray->length-(index+length))*sizeof(*bytearray->items));
52 bytearray->length -= length;
53}
54
55
56void* bytearray_pop_at(Bytearray* bytearray, size_t index, void* retptr)
57{
58 void *tmp;
59
60 tmp = bytearray_at(bytearray, index);
61 if(!tmp)
62 return NULL;
63
64 retptr = retptr ? retptr : malloc(bytearray->element_size);
65 if(!retptr)
66 return NULL;
67
68 memcpy(retptr, tmp, bytearray->element_size);
69 bytearray_remove(bytearray, index, NULL);
70 return retptr;
71}
72
73bool bytearray_insert(Bytearray* bytearray, size_t index, const void* item)
74{
75 size_t length = bytearray->length;
76 size_t size = bytearray->element_size;
77
78 if(index > length || !bytearray_grow(bytearray, 1))
79 return false;
80
81 memmove(bytearray->items+index*size+1*size, bytearray->items+index*size, (length*size-index*size)*sizeof(*bytearray->items));
82 memcpy(bytearray->items+index*size, item, bytearray->element_size);
83 bytearray->length++;
84 return true;
85}
86
87bool bytearray_grow(Bytearray* bytearray, size_t add)
88{
89 if(bytearray->length+add < bytearray->length)
90 return false;
91 return bytearray_adjust_size(bytearray, bytearray->length+add);
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