1 /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
\r
2 * This file is part of clib library
\r
3 * Copyright (C) 2011 Avinash Dongre ( dongre.avinash@gmail.com )
\r
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
\r
6 * of this software and associated documentation files (the "Software"), to deal
\r
7 * in the Software without restriction, including without limitation the rights
\r
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
\r
9 * copies of the Software, and to permit persons to whom the Software is
\r
10 * furnished to do so, subject to the following conditions:
\r
12 * The above copyright notice and this permission notice shall be included in
\r
13 * all copies or substantial portions of the Software.
\r
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
\r
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
\r
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
\r
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
\r
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
\r
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
\r
22 ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/
\r
29 static struct clib_array*
\r
30 array_check_and_grow ( struct clib_array* pArray) {
\r
31 if ( pArray->no_of_elements >= pArray->no_max_elements ) {
\r
32 pArray->no_max_elements = 2 * pArray->no_max_elements;
\r
33 pArray->pElements = (struct clib_object**) realloc ( pArray->pElements,
\r
34 pArray->no_max_elements * sizeof ( struct clib_object*));
\r
40 new_clib_array(int array_size, clib_compare fn_c, clib_destroy fn_d) {
\r
42 struct clib_array* pArray = (struct clib_array*)malloc(sizeof(struct clib_array));
\r
44 return (struct clib_array*)0;
\r
46 pArray->no_max_elements = array_size < 8 ? 8 : array_size;
\r
47 pArray->pElements = (struct clib_object**) malloc(pArray->no_max_elements * sizeof(struct clib_object*));
\r
48 if ( ! pArray->pElements ){
\r
50 return (struct clib_array*)0;
\r
52 pArray->compare_fn = fn_c;
\r
53 pArray->destruct_fn = fn_d;
\r
54 pArray->no_of_elements = 0;
\r
60 insert_clib_array ( struct clib_array* pArray, int index, void *elem, size_t elem_size) {
\r
62 clib_error rc = CLIB_ERROR_SUCCESS;
\r
63 struct clib_object* pObject = new_clib_object ( elem, elem_size );
\r
65 return CLIB_ARRAY_INSERT_FAILED;
\r
67 pArray->pElements[index] = pObject;
\r
68 pArray->no_of_elements++;
\r
73 push_back_clib_array (struct clib_array* pArray, void *elem, size_t elem_size) {
\r
74 clib_error rc = CLIB_ERROR_SUCCESS;
\r
77 return CLIB_ARRAY_NOT_INITIALIZED;
\r
79 array_check_and_grow ( pArray);
\r
81 rc = insert_clib_array( pArray, pArray->no_of_elements, elem, elem_size);
\r
87 element_at_clib_array (struct clib_array* pArray, int index, void** elem) {
\r
88 clib_error rc = CLIB_ERROR_SUCCESS;
\r
91 return CLIB_ARRAY_NOT_INITIALIZED;
\r
93 if ( index < 0 || index >= pArray->no_of_elements )
\r
94 return CLIB_ARRAY_INDEX_OUT_OF_BOUND;
\r
96 get_raw_clib_object ( pArray->pElements[index], elem );
\r
101 size_clib_array ( struct clib_array* pArray ) {
\r
102 if ( pArray == (struct clib_array*)0 )
\r
104 return pArray->no_of_elements;
\r
108 capacity_clib_array ( struct clib_array* pArray ) {
\r
109 if ( pArray == (struct clib_array*)0 )
\r
111 return pArray->no_max_elements;
\r
115 empty_clib_array ( struct clib_array* pArray) {
\r
116 if ( pArray == (struct clib_array*)0 )
\r
118 if ( pArray->no_of_elements == 0 )
\r
125 reserve_clib_array ( struct clib_array* pArray, int new_size) {
\r
126 if ( pArray == (struct clib_array*)0 )
\r
127 return CLIB_ARRAY_NOT_INITIALIZED;
\r
129 if ( new_size <= pArray->no_max_elements )
\r
130 return CLIB_ERROR_SUCCESS;
\r
132 array_check_and_grow ( pArray);
\r
133 return CLIB_ERROR_SUCCESS;
\r
138 front_clib_array ( struct clib_array* pArray,void *elem) {
\r
139 return element_at_clib_array ( pArray, 0, elem );
\r
143 back_clib_array ( struct clib_array* pArray,void *elem) {
\r
144 return element_at_clib_array ( pArray, pArray->no_of_elements - 1, elem );
\r
148 insert_at_clib_array ( struct clib_array* pArray, int index, void *elem, size_t elem_size) {
\r
149 clib_error rc = CLIB_ERROR_SUCCESS;
\r
151 return CLIB_ARRAY_NOT_INITIALIZED;
\r
153 if ( index < 0 || index > pArray->no_max_elements )
\r
154 return CLIB_ARRAY_INDEX_OUT_OF_BOUND;
\r
156 array_check_and_grow ( pArray);
\r
158 memmove ( &(pArray->pElements[index + 1]),
\r
159 &pArray->pElements[index],
\r
160 (pArray->no_of_elements - index ) * sizeof(struct clib_object*));
\r
162 rc = insert_clib_array ( pArray, index, elem , elem_size);
\r
168 remove_clib_array ( struct clib_array* pArray, int index) {
\r
169 clib_error rc = CLIB_ERROR_SUCCESS;
\r
173 if ( index < 0 || index >= pArray->no_of_elements )
\r
174 return CLIB_ARRAY_INDEX_OUT_OF_BOUND;
\r
176 if ( pArray->destruct_fn ) {
\r
178 if ( CLIB_ERROR_SUCCESS == element_at_clib_array ( pArray, index , &elem ) ) {
\r
179 pArray->destruct_fn(elem);
\r
182 delete_clib_object ( pArray->pElements[index]);
\r
184 if ( index != pArray->no_of_elements - 1 ) {
\r
185 memmove ( &(pArray->pElements[index]),
\r
186 &pArray->pElements[index + 1],
\r
187 (pArray->no_of_elements - index ) * sizeof(struct clib_object*));
\r
189 pArray->no_of_elements--;
\r
194 delete_clib_array( struct clib_array* pArray) {
\r
195 clib_error rc = CLIB_ERROR_SUCCESS;
\r
198 if ( pArray == (struct clib_array*)0 )
\r
201 if ( pArray->destruct_fn ) {
\r
202 for ( i = 0; i < pArray->no_of_elements; i++) {
\r
204 if ( CLIB_ERROR_SUCCESS == element_at_clib_array ( pArray, i , &elem ) )
\r
205 pArray->destruct_fn(elem);
\r
208 for ( i = 0; i < pArray->no_of_elements; i++)
\r
209 delete_clib_object ( pArray->pElements[i]);
\r
211 free ( pArray->pElements);
\r
217 swap_element_clib_array ( struct clib_array *pArray, int left, int right) {
\r
218 struct clib_object *temp = pArray->pElements[left];
\r
219 pArray->pElements[left] = pArray->pElements[right];
\r
220 pArray->pElements[right] = temp;
\r
223 void for_each_clib_array ( struct clib_array *pArray, void (*fn)(void*)) {
\r
224 int size = pArray->no_of_elements;
\r
226 for ( i = 0; i < size; i++ ) {
\r
228 element_at_clib_array ( pArray, i , &elem);
\r