2 #include <TThreadDynarray.h>
5 * Constructs a ThreadDynarray with the specified capacity.
7 ThreadDynarray_t ThreadDynarray_new(unsigned long capacity)
9 ThreadDynarray_t ptr = calloc(1, sizeof(s_ThreadDynarray_t));
12 ptr->capacity = capacity;
14 memset(&(ptr->cs), 0, sizeof(CRITICAL_SECTION));
15 InitializeCriticalSection(&(ptr->cs));
16 ptr->is_locked = false;
20 (ThreadEntry_t) calloc(capacity, sizeof(s_ThreadEntry_t));
28 * Destroy the ThreadDynarray
30 void ThreadDynarray_destroy(ThreadDynarray_t ptr)
32 ThreadDynarray_clear(ptr);
33 DeleteCriticalSection(&(ptr->cs));
39 * Returns an const pointer to entry pointed to by index.
41 ThreadEntry_t const ThreadDynarray_at(ThreadDynarray_t ptr,
44 ThreadEntry_t __entry;
45 ThreadDynarray_lock(ptr);
46 __entry = &(ptr->threads)[index];
47 ThreadDynarray_unlock(ptr);
52 * Fill the content of the entry addressed by __entry with the content
53 * of the entry pointed to by index.
55 void ThreadDynarray_get(ThreadDynarray_t ptr, unsigned long index,
56 ThreadEntry_t const __entry)
58 ThreadDynarray_lock(ptr);
59 ::memcpy(__entry, ThreadDynarray_at(ptr, index),
60 sizeof(s_ThreadEntry_t));
61 ThreadDynarray_unlock(ptr);
65 * Fill the content of the entry pointed to by index with the content of
66 * the entry addressed by __entry.
68 void ThreadDynarray_set(ThreadDynarray_t ptr, unsigned long index,
69 ThreadEntry_t const __entry)
72 ThreadDynarray_lock(ptr);
73 memcpy(ThreadDynarray_at(ptr, index), __entry, sizeof(s_ThreadEntry_t));
74 ThreadDynarray_unlock(ptr);
78 * Returns a const pointer to the first entry.
80 ThreadEntry_t const ThreadDynarray_getFront(ThreadDynarray_t ptr)
82 ThreadEntry_t __entry;
83 ThreadDynarray_lock(ptr);
84 __entry = ThreadDynarray_at(ptr, 0);
85 ThreadDynarray_unlock(ptr);
90 * Returns a const pointer to the last entry.
92 ThreadEntry_t const ThreadDynarray_getBack(ThreadDynarray_t ptr)
94 ThreadEntry_t __entry;
95 ThreadDynarray_lock(ptr);
96 __entry = ThreadDynarray_at(ptr, ptr->count - 1);;
97 ThreadDynarray_unlock(ptr);
102 * Inserts a copy of __entry at the front
104 void ThreadDynarray_pushFront(ThreadDynarray_t ptr,
105 ThreadEntry_t const __entry)
107 ThreadDynarray_lock(ptr);
109 if (!ThreadDynarray_getCapacityAvailable(ptr))
110 ThreadDynarray_resize(ptr);
113 ThreadDynarray_move(ptr, 1, ThreadDynarray_getLowerBound(ptr),
114 ThreadDynarray_getUpperBound(ptr));
115 ThreadDynarray_set(ptr, ThreadDynarray_getLowerBound(ptr), __entry);
117 ThreadDynarray_unlock(ptr);
121 * Appends a copy of __entry to the end.
123 void ThreadDynarray_pushBack(ThreadDynarray_t ptr,
124 ThreadEntry_t const __entry)
126 ThreadDynarray_lock(ptr);
128 if (!ThreadDynarray_getCapacityAvailable(ptr))
129 ThreadDynarray_resize(ptr);
132 ThreadDynarray_set(ptr, ThreadDynarray_getUpperBound(ptr), __entry);
134 ThreadDynarray_unlock(ptr);
139 * Inserts __entry at the position pointed to by index.
141 void ThreadDynarray_insert(ThreadDynarray_t ptr, unsigned long index,
142 ThreadEntry_t const __entry)
144 ThreadDynarray_lock(ptr);
146 if (!ThreadDynarray_getCapacityAvailable(ptr))
147 ThreadDynarray_resize(ptr);
149 ThreadDynarray_move(ptr, index + 1, index, ptr->count - index);
151 ThreadDynarray_set(ptr, index, __entry);
153 ThreadDynarray_unlock(ptr);
157 * Deletes the entry pointed to by index. If __entry is not NULL the
158 * fuction saves the entry threads at this address before.
160 void ThreadDynarray_erase(ThreadDynarray_t ptr, unsigned long index,
161 ThreadEntry_t const __entry)
164 ThreadDynarray_lock(ptr);
167 ThreadDynarray_set(ptr, index, __entry);
169 if (index != ThreadDynarray_getUpperBound(ptr))
170 ThreadDynarray_move(ptr, index, index + 1, (ptr->count - (index + 1)));
174 ThreadDynarray_unlock(ptr);
178 * Find the first entry with the same content of the entry addressed by
179 * __entry.The function returns the index of the founded entry, -1 if
180 * no entry is founded.
182 long ThreadDynarray_getIndex(ThreadDynarray_t ptr,
183 ThreadEntry_t const __entry)
187 ThreadDynarray_lock(ptr);
189 for (i = 0; i < ptr->count; i++) {
190 if (ThreadDynarray_compare(ptr, i, __entry)) {
191 ThreadDynarray_unlock(ptr);
196 ThreadDynarray_unlock(ptr);
201 * Returns true if the entry exist.
203 bool ThreadDynarray_exist(ThreadDynarray_t ptr,
204 ThreadEntry_t const __entry)
208 ThreadDynarray_lock(ptr);
209 exist = (-1 != ThreadDynarray_getIndex(ptr, __entry));
210 ThreadDynarray_unlock(ptr);
214 /* Deletes the first entry with the same content of the entry addressed
215 * by __entry.The function returns true if the entry is deleted, false
216 * if no entry is founded.
218 bool ThreadDynarray_remove(ThreadDynarray_t ptr,
219 ThreadEntry_t const __entry)
221 /* assert(!empty(ptr)); */
224 ThreadDynarray_lock(ptr);
225 __index = ThreadDynarray_getIndex(ptr, __entry);
228 ThreadDynarray_unlock(ptr);
232 ThreadDynarray_set(ptr, (unsigned long) __index, NULL);
233 ThreadDynarray_unlock(ptr);
238 * Erase all elements of the self.
240 void ThreadDynarray_clear(ThreadDynarray_t ptr)
242 ThreadDynarray_lock(ptr);
251 ThreadDynarray_unlock(ptr);
255 * Resets entry count to zero.
257 void ThreadDynarray_reset(ThreadDynarray_t ptr)
259 ThreadDynarray_lock(ptr);
261 ThreadDynarray_unlock(ptr);
265 * Moves count elements from src index to dst index.
267 void ThreadDynarray_move(ThreadDynarray_t ptr, const unsigned long dst,
268 const unsigned long src, unsigned long count)
270 ThreadDynarray_lock(ptr);
273 memmove(ThreadDynarray_at(ptr, dst), ThreadDynarray_at(ptr, src),
274 count * sizeof(s_ThreadEntry_t));
276 ThreadDynarray_unlock(ptr);
279 /* Compare the content of the entry pointed to by index with the content of
280 * the entry addressed by __entry. The function returns true if the contents
283 bool ThreadDynarray_compare(ThreadDynarray_t ptr,
284 const unsigned long index,
285 ThreadEntry_t const __entry)
288 ThreadDynarray_lock(ptr);
291 (ThreadDynarray_at(ptr, index), __entry, sizeof(s_ThreadEntry_t)));
292 ThreadDynarray_unlock(ptr);
297 * Returns a reference to a new ThreadDynarray new set is a clone of the self.
299 ThreadDynarray_t ThreadDynarray_clone(ThreadDynarray_t ptr)
301 ThreadDynarray_t new_ptr;
302 ThreadDynarray_lock(ptr);
303 ptr = ThreadDynarray_new(ptr->capacity);
306 memcpy(new_ptr->threads, ptr->threads,
307 ptr->count * sizeof(s_ThreadEntry_t));
308 new_ptr->count = ThreadDynarray_getCount(ptr);
310 ThreadDynarray_unlock(ptr);
315 * Extends the capacity when the container is full.
317 void ThreadDynarray_resize(ThreadDynarray_t ptr)
319 ThreadDynarray_lock(ptr);
321 ptr->capacity = (!ptr->capacity) ? 1 : (ptr->count << 1);
323 (ThreadEntry_t) realloc(ptr->threads,
324 ptr->capacity * sizeof(s_ThreadEntry_t));
326 ThreadDynarray_unlock(ptr);
331 * Returns the number of elements.
333 unsigned long ThreadDynarray_getCount(ThreadDynarray_t ptr)
336 ThreadDynarray_lock(ptr);
338 ThreadDynarray_unlock(ptr);
343 * Returns the current storage capacity of the ThreadDynarray. This is guaranteed
344 * to be at least as large as count().
346 unsigned long ThreadDynarray_getCapacity(ThreadDynarray_t ptr)
349 ThreadDynarray_lock(ptr);
350 capacity = ptr->capacity;
351 ThreadDynarray_unlock(ptr);
357 * Returns upper bound of self (max index).
359 unsigned long ThreadDynarray_getUpperBound(ThreadDynarray_t ptr)
361 unsigned long upper_bound;
362 ThreadDynarray_lock(ptr);
363 upper_bound = (ptr->count - 1);
364 ThreadDynarray_unlock(ptr);
369 * Returns lower bound of self (always zero).
371 unsigned long ThreadDynarray_getLowerBound(ThreadDynarray_t ptr)
377 * Returns the size of the elements.
379 unsigned long ThreadDynarray_getElementSize(ThreadDynarray_t ptr)
381 return sizeof(s_ThreadEntry_t);
385 * Returns true if the size of self is zero.
387 bool ThreadDynarray_isEmpty(ThreadDynarray_t ptr)
390 ThreadDynarray_lock(ptr);
391 is_empty = (ptr->count == 0);
392 ThreadDynarray_unlock(ptr);
397 * Returns true if capacity available.
399 bool ThreadDynarray_getCapacityAvailable(ThreadDynarray_t ptr)
401 bool capacity_available;
402 ThreadDynarray_lock(ptr);
403 capacity_available = (ptr->capacity > ptr->count);
404 ThreadDynarray_unlock(ptr);
405 return capacity_available;
409 * Returns true if the container is full.
411 bool ThreadDynarray_is_full(ThreadDynarray_t ptr)
414 ThreadDynarray_lock(ptr);
415 is_full = (!ThreadDynarray_isEmpty(ptr)
416 && !ThreadDynarray_getCapacityAvailable(ptr));
417 ThreadDynarray_unlock(ptr);
424 ThreadDynarray_t ThreadDynarray_assign(ThreadDynarray_t src,
425 ThreadDynarray_t dst)
427 ThreadDynarray_lock(src);
428 ThreadDynarray_lock(dst);
431 ThreadDynarray_clear(dst);
434 dst->count = src->count;
435 dst->capacity = src->capacity;
437 (ThreadEntry_t) malloc(src->capacity * sizeof(s_ThreadEntry_t));
438 memcpy(dst->threads, src->threads,
439 src->count * sizeof(s_ThreadEntry_t));
442 ThreadDynarray_unlock(src);
443 ThreadDynarray_unlock(dst);
449 * Returns true if the dynamic arrays are equal.
451 bool ThreadDynarray_areEquals(ThreadDynarray_t ptr1, ThreadDynarray_t ptr2)
455 ThreadDynarray_lock(ptr1);
456 ThreadDynarray_lock(ptr2);
458 are_equals = (ptr1->count == ptr2->count &&
459 ptr1->capacity == ptr2->capacity &&
460 !memcmp(ptr2->threads, ptr1->threads, ptr1->capacity)
463 ThreadDynarray_unlock(ptr1);
464 ThreadDynarray_unlock(ptr2);
470 * Returns true if the dynamic arrays are not equal.
472 ThreadDynarray_areNotEquals(ThreadDynarray_t ptr1, ThreadDynarray_t ptr2)
474 return !ThreadDynarray_areEquals(ptr1, ptr2);
477 void ThreadDynarray_lock(ThreadDynarray_t ptr)
479 if (!ptr->is_locked) {
480 EnterCriticalSection(&(ptr->cs));
481 ptr->is_locked = true;
485 void ThreadDynarray_unlock(ThreadDynarray_t ptr)
487 if (ptr->is_locked) {
488 LeaveCriticalSection(&(ptr->cs));
489 ptr->is_locked = false;