Fixed bug in u_arraylist_contains caused by poor member naming.
[platform/upstream/iotivity.git] / resource / csdk / connectivity / common / src / uarraylist.c
1 /******************************************************************
2  *
3  * Copyright 2014 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************/
20
21 #include <stdlib.h>
22 #include <string.h>
23 #include "uarraylist.h"
24 #include "logger.h"
25 #include "oic_malloc.h"
26
27 #define TAG "UARRAYLIST"
28
29 /**
30  * Use this default capacity when initialized
31  */
32 #define U_ARRAYLIST_DEFAULT_CAPACITY 1
33
34 u_arraylist_t *u_arraylist_create()
35 {
36     u_arraylist_t *list = (u_arraylist_t *) OICMalloc(sizeof(u_arraylist_t));
37     if (!list)
38     {
39         OIC_LOG(DEBUG, TAG, "Out of memory");
40         return NULL;
41     }
42
43     list->capacity = U_ARRAYLIST_DEFAULT_CAPACITY;
44     list->length = 0;
45
46     list->data = (void **) OICMalloc(list->capacity * sizeof(list->data[0]));
47     if (!list->data)
48     {
49         OIC_LOG(DEBUG, TAG, "Out of memory");
50         OICFree(list);
51         return NULL;
52     }
53     return list;
54 }
55
56 void u_arraylist_free(u_arraylist_t **list)
57 {
58     if (!list || !(*list))
59     {
60         return;
61     }
62
63     OICFree((*list)->data);
64     OICFree(*list);
65
66     *list = NULL;
67 }
68
69 void u_arraylist_reserve(u_arraylist_t *list, size_t count)
70 {
71     if (list && (count > list->capacity))
72     {
73         void *tmp = OICRealloc(list->data, count * sizeof(list->data[0]));
74         if (!tmp)
75         {
76             OIC_LOG(DEBUG, TAG, "Memory reallocation failed.");
77             // Note that this is considered non-fatal.
78         }
79         else
80         {
81             list->data = (void **) tmp;
82             list->capacity = count;
83         }
84     }
85 }
86
87 void u_arraylist_shrink_to_fit(u_arraylist_t *list)
88 {
89     if (!list)
90     {
91         return;
92     }
93
94     if ((list->capacity > list->length)
95         && (list->length >= U_ARRAYLIST_DEFAULT_CAPACITY))
96     {
97         void *tmp = OICRealloc(list->data,
98                                list->length * sizeof(list->data[0]));
99         if (!tmp)
100         {
101             OIC_LOG(DEBUG, TAG, "Memory reallocation failed.");
102             // Considered non-fatal as this call is non-binding.
103         }
104         else
105         {
106             list->data = (void **) tmp;
107             list->capacity = list->length;
108         }
109     }
110 }
111
112 void *u_arraylist_get(const u_arraylist_t *list, uint32_t index)
113 {
114     if (!list )
115     {
116         return NULL;
117     }
118
119     if ((index < list->length) && (list->data))
120     {
121         return list->data[index];
122     }
123
124     return NULL;
125 }
126
127 bool u_arraylist_add(u_arraylist_t *list, void *data)
128 {
129     static const double GROWTH_FACTOR = 1.5;
130     if (!list)
131     {
132         return false;
133     }
134
135     if (list->capacity <= list->length)
136     {
137         uint32_t new_capacity = (list->capacity * GROWTH_FACTOR) + 0.5;
138         // In case the re-alloc returns null, use a local variable to avoid
139         // losing the current block of memory.
140         void *tmp = OICRealloc(list->data,
141                                new_capacity * sizeof(list->data[0]));
142         if (!tmp)
143         {
144             OIC_LOG(DEBUG, TAG, "Memory reallocation failed.");
145             return false;
146         }
147         list->data = (void **) tmp;
148         memset(list->data + list->capacity, 0,
149                (new_capacity - list->capacity) * sizeof(list->data[0]));
150         list->capacity = new_capacity;
151     }
152
153     list->data[list->length] = data;
154     list->length++;
155
156     return true;
157 }
158
159 void *u_arraylist_remove(u_arraylist_t *list, uint32_t index)
160 {
161     void *removed = NULL;
162
163     if (!list || (index >= list->length))
164     {
165         return NULL;
166     }
167
168     removed = list->data[index];
169
170     if (index < list->length - 1)
171     {
172         memmove(&list->data[index],
173                 &list->data[index + 1],
174                 (list->length - index - 1) * sizeof(list->data[0]));
175     }
176
177     list->length--;
178
179     return removed;
180 }
181
182 uint32_t u_arraylist_length(const u_arraylist_t *list)
183 {
184     if (!list)
185     {
186         OIC_LOG(DEBUG, TAG, "Invalid Parameter");
187         return 0;
188     }
189     return list->length;
190 }
191
192 bool u_arraylist_contains(const u_arraylist_t *list, const void *data)
193 {
194     if (!list)
195     {
196         return false;
197     }
198
199     for (uint32_t i = 0; i < list->length; i++)
200     {
201         if (data == list->data[i])
202         {
203             return true;
204         }
205     }
206
207     return false;
208 }
209
210 // Assumes elements are shallow (have no pointers to allocated memory)
211 void u_arraylist_destroy(u_arraylist_t *list)
212 {
213     if (!list)
214     {
215         return;
216     }
217     for (uint32_t i = 0; i < list->length; i++)
218     {
219         OICFree(list->data[i]);
220     }
221     (void)u_arraylist_free(&list);
222 }