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;
19 ptr->threads = (ThreadEntry_t)calloc(capacity,sizeof(s_ThreadEntry_t));
27 * Destroy the ThreadDynarray
29 void ThreadDynarray_destroy(ThreadDynarray_t ptr)
31 ThreadDynarray_clear(ptr);
32 DeleteCriticalSection(&(ptr->cs));
38 * Returns an const pointer to entry pointed to by index.
40 ThreadEntry_t const ThreadDynarray_at(ThreadDynarray_t ptr, unsigned long index)
42 ThreadEntry_t __entry;
43 ThreadDynarray_lock(ptr);
44 __entry = &(ptr->threads)[index];
45 ThreadDynarray_unlock(ptr);
50 * Fill the content of the entry addressed by __entry with the content
51 * of the entry pointed to by index.
53 void ThreadDynarray_get(ThreadDynarray_t ptr, unsigned long index, ThreadEntry_t const __entry)
55 ThreadDynarray_lock(ptr);
56 ::memcpy(__entry,ThreadDynarray_at(ptr,index),sizeof(s_ThreadEntry_t));
57 ThreadDynarray_unlock(ptr);
61 * Fill the content of the entry pointed to by index with the content of
62 * the entry addressed by __entry.
64 void ThreadDynarray_set(ThreadDynarray_t ptr, unsigned long index, ThreadEntry_t const __entry)
67 ThreadDynarray_lock(ptr);
68 memcpy(ThreadDynarray_at(ptr,index),__entry,sizeof(s_ThreadEntry_t));
69 ThreadDynarray_unlock(ptr);
73 * Returns a const pointer to the first entry.
75 ThreadEntry_t const ThreadDynarray_getFront(ThreadDynarray_t ptr)
77 ThreadEntry_t __entry;
78 ThreadDynarray_lock(ptr);
79 __entry = ThreadDynarray_at(ptr,0);
80 ThreadDynarray_unlock(ptr);
85 * Returns a const pointer to the last entry.
87 ThreadEntry_t const ThreadDynarray_getBack(ThreadDynarray_t ptr)
89 ThreadEntry_t __entry;
90 ThreadDynarray_lock(ptr);
91 __entry = ThreadDynarray_at(ptr,ptr->count - 1);;
92 ThreadDynarray_unlock(ptr);
97 * Inserts a copy of __entry at the front
99 void ThreadDynarray_pushFront(ThreadDynarray_t ptr, ThreadEntry_t const __entry)
101 ThreadDynarray_lock(ptr);
103 if(!ThreadDynarray_getCapacityAvailable(ptr))
104 ThreadDynarray_resize(ptr);
107 ThreadDynarray_move(ptr,1,ThreadDynarray_getLowerBound(ptr),ThreadDynarray_getUpperBound(ptr));
108 ThreadDynarray_set(ptr,ThreadDynarray_getLowerBound(ptr),__entry);
110 ThreadDynarray_unlock(ptr);
114 * Appends a copy of __entry to the end.
116 void ThreadDynarray_pushBack(ThreadDynarray_t ptr, ThreadEntry_t const __entry)
118 ThreadDynarray_lock(ptr);
120 if(!ThreadDynarray_getCapacityAvailable(ptr))
121 ThreadDynarray_resize(ptr);
124 ThreadDynarray_set(ptr,ThreadDynarray_getUpperBound(ptr),__entry);
126 ThreadDynarray_unlock(ptr);
131 * Inserts __entry at the position pointed to by index.
133 void ThreadDynarray_insert(ThreadDynarray_t ptr, unsigned long index, ThreadEntry_t const __entry)
135 ThreadDynarray_lock(ptr);
137 if(!ThreadDynarray_getCapacityAvailable(ptr))
138 ThreadDynarray_resize(ptr);
140 ThreadDynarray_move(ptr,index + 1,index,ptr->count - index);
142 ThreadDynarray_set(ptr,index,__entry);
144 ThreadDynarray_unlock(ptr);
148 * Deletes the entry pointed to by index. If __entry is not NULL the
149 * fuction saves the entry threads at this address before.
151 void ThreadDynarray_erase(ThreadDynarray_t ptr, unsigned long index,ThreadEntry_t const __entry)
154 ThreadDynarray_lock(ptr);
157 ThreadDynarray_set(ptr,index,__entry);
159 if(index != ThreadDynarray_getUpperBound(ptr))
160 ThreadDynarray_move(ptr,index,index + 1,(ptr->count - (index + 1)));
164 ThreadDynarray_unlock(ptr);
168 * Find the first entry with the same content of the entry addressed by
169 * __entry.The function returns the index of the founded entry, -1 if
170 * no entry is founded.
172 long ThreadDynarray_getIndex(ThreadDynarray_t ptr, ThreadEntry_t const __entry)
176 ThreadDynarray_lock(ptr);
178 for(i = 0; i < ptr->count; i++){
179 if(ThreadDynarray_compare(ptr,i,__entry)){
180 ThreadDynarray_unlock(ptr);
185 ThreadDynarray_unlock(ptr);
190 * Returns true if the entry exist.
192 bool ThreadDynarray_exist(ThreadDynarray_t ptr, ThreadEntry_t const __entry)
196 ThreadDynarray_lock(ptr);
197 exist = (-1 != ThreadDynarray_getIndex(ptr,__entry));
198 ThreadDynarray_unlock(ptr);
202 /* Deletes the first entry with the same content of the entry addressed
203 * by __entry.The function returns true if the entry is deleted, false
204 * if no entry is founded.
206 bool ThreadDynarray_remove(ThreadDynarray_t ptr, ThreadEntry_t const __entry)
208 /* assert(!empty(ptr)); */
211 ThreadDynarray_lock(ptr);
212 __index = ThreadDynarray_getIndex(ptr,__entry);
215 ThreadDynarray_unlock(ptr);
219 ThreadDynarray_set(ptr,(unsigned long)__index,NULL);
220 ThreadDynarray_unlock(ptr);
225 * Erase all elements of the self.
227 void ThreadDynarray_clear(ThreadDynarray_t ptr)
229 ThreadDynarray_lock(ptr);
238 ThreadDynarray_unlock(ptr);
242 * Resets entry count to zero.
244 void ThreadDynarray_reset(ThreadDynarray_t ptr)
246 ThreadDynarray_lock(ptr);
248 ThreadDynarray_unlock(ptr);
252 * Moves count elements from src index to dst index.
254 void ThreadDynarray_move(ThreadDynarray_t ptr, const unsigned long dst,const unsigned long src,unsigned long count)
256 ThreadDynarray_lock(ptr);
259 memmove(ThreadDynarray_at(ptr,dst),ThreadDynarray_at(ptr,src),count * sizeof(s_ThreadEntry_t));
261 ThreadDynarray_unlock(ptr);
264 /* Compare the content of the entry pointed to by index with the content of
265 * the entry addressed by __entry. The function returns true if the contents
268 bool ThreadDynarray_compare(ThreadDynarray_t ptr, const unsigned long index,ThreadEntry_t const __entry)
271 ThreadDynarray_lock(ptr);
272 are_equals = (!memcmp(ThreadDynarray_at(ptr,index),__entry,sizeof(s_ThreadEntry_t)));
273 ThreadDynarray_unlock(ptr);
278 * Returns a reference to a new ThreadDynarray new set is a clone of the self.
280 ThreadDynarray_t ThreadDynarray_clone(ThreadDynarray_t ptr)
282 ThreadDynarray_t new_ptr;
283 ThreadDynarray_lock(ptr);
284 ptr = ThreadDynarray_new(ptr->capacity);
287 memcpy(new_ptr->threads,ptr->threads,ptr->count * sizeof(s_ThreadEntry_t));
288 new_ptr->count=ThreadDynarray_getCount(ptr);
290 ThreadDynarray_unlock(ptr);
295 * Extends the capacity when the container is full.
297 void ThreadDynarray_resize(ThreadDynarray_t ptr)
299 ThreadDynarray_lock(ptr);
301 ptr->capacity = (!ptr->capacity) ? 1 : (ptr->count << 1);
302 ptr->threads = (ThreadEntry_t)realloc(ptr->threads, ptr->capacity * sizeof(s_ThreadEntry_t));
304 ThreadDynarray_unlock(ptr);
309 * Returns the number of elements.
311 unsigned long ThreadDynarray_getCount(ThreadDynarray_t ptr)
314 ThreadDynarray_lock(ptr);
316 ThreadDynarray_unlock(ptr);
321 * Returns the current storage capacity of the ThreadDynarray. This is guaranteed
322 * to be at least as large as count().
324 unsigned long ThreadDynarray_getCapacity(ThreadDynarray_t ptr)
327 ThreadDynarray_lock(ptr);
328 capacity = ptr->capacity;
329 ThreadDynarray_unlock(ptr);
335 * Returns upper bound of self (max index).
337 unsigned long ThreadDynarray_getUpperBound(ThreadDynarray_t ptr)
339 unsigned long upper_bound;
340 ThreadDynarray_lock(ptr);
341 upper_bound = (ptr->count - 1);
342 ThreadDynarray_unlock(ptr);
347 * Returns lower bound of self (always zero).
349 unsigned long ThreadDynarray_getLowerBound(ThreadDynarray_t ptr)
355 * Returns the size of the elements.
357 unsigned long ThreadDynarray_getElementSize(ThreadDynarray_t ptr)
359 return sizeof(s_ThreadEntry_t);
363 * Returns true if the size of self is zero.
365 bool ThreadDynarray_isEmpty(ThreadDynarray_t ptr)
368 ThreadDynarray_lock(ptr);
369 is_empty = (ptr->count == 0);
370 ThreadDynarray_unlock(ptr);
375 * Returns true if capacity available.
377 bool ThreadDynarray_getCapacityAvailable(ThreadDynarray_t ptr)
379 bool capacity_available;
380 ThreadDynarray_lock(ptr);
381 capacity_available = (ptr->capacity > ptr->count);
382 ThreadDynarray_unlock(ptr);
383 return capacity_available;
387 * Returns true if the container is full.
389 bool ThreadDynarray_is_full(ThreadDynarray_t ptr)
392 ThreadDynarray_lock(ptr);
393 is_full = (!ThreadDynarray_isEmpty(ptr) && !ThreadDynarray_getCapacityAvailable(ptr));
394 ThreadDynarray_unlock(ptr);
401 ThreadDynarray_t ThreadDynarray_assign(ThreadDynarray_t src,ThreadDynarray_t dst)
403 ThreadDynarray_lock(src);
404 ThreadDynarray_lock(dst);
408 ThreadDynarray_clear(dst);
412 dst->count = src->count;
413 dst->capacity = src->capacity;
414 dst->threads = (ThreadEntry_t)malloc(src->capacity * sizeof(s_ThreadEntry_t));
415 memcpy(dst->threads,src->threads,src->count * sizeof(s_ThreadEntry_t));
418 ThreadDynarray_unlock(src);
419 ThreadDynarray_unlock(dst);
425 * Returns true if the dynamic arrays are equal.
427 bool ThreadDynarray_areEquals(ThreadDynarray_t ptr1,ThreadDynarray_t ptr2)
431 ThreadDynarray_lock(ptr1);
432 ThreadDynarray_lock(ptr2);
435 ptr1->count == ptr2->count &&
436 ptr1->capacity == ptr2->capacity &&
437 !memcmp(ptr2->threads,ptr1->threads,ptr1->capacity)
440 ThreadDynarray_unlock(ptr1);
441 ThreadDynarray_unlock(ptr2);
447 * Returns true if the dynamic arrays are not equal.
449 ThreadDynarray_areNotEquals(ThreadDynarray_t ptr1,ThreadDynarray_t ptr2)
451 return !ThreadDynarray_areEquals(ptr1,ptr2);
454 void ThreadDynarray_lock(ThreadDynarray_t ptr)
457 EnterCriticalSection(&(ptr->cs));
458 ptr->is_locked = true;
462 void ThreadDynarray_unlock(ThreadDynarray_t ptr)
465 LeaveCriticalSection(&(ptr->cs));
466 ptr->is_locked = false;