typedef void (*OBJECT_INIT_FN)(void* obj);
typedef void (*OBJECT_UNINIT_FN)(void* obj);
typedef void (*OBJECT_FREE_FN)(void* obj);
-typedef BOOL (*OBJECT_EQUALS_FN)(void* objA, void* objB);
+typedef BOOL (*OBJECT_EQUALS_FN)(const void* objA, const void* objB);
struct _wObject
{
WINPR_API void ListDictionary_Lock(wListDictionary* listDictionary);
WINPR_API void ListDictionary_Unlock(wListDictionary* listDictionary);
-WINPR_API BOOL ListDictionary_Add(wListDictionary* listDictionary, void* key, void* value);
-WINPR_API void* ListDictionary_Remove(wListDictionary* listDictionary, void* key);
+WINPR_API BOOL ListDictionary_Add(wListDictionary* listDictionary, const void* key, void* value);
+WINPR_API void* ListDictionary_Remove(wListDictionary* listDictionary, const void* key);
WINPR_API void* ListDictionary_Remove_Head(wListDictionary* listDictionary);
WINPR_API void ListDictionary_Clear(wListDictionary* listDictionary);
-WINPR_API BOOL ListDictionary_Contains(wListDictionary* listDictionary, void* key);
+WINPR_API BOOL ListDictionary_Contains(wListDictionary* listDictionary, const void* key);
WINPR_API int ListDictionary_GetKeys(wListDictionary* listDictionary, ULONG_PTR** ppKeys);
-WINPR_API void* ListDictionary_GetItemValue(wListDictionary* listDictionary, void* key);
-WINPR_API BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, void* key, void* value);
+WINPR_API void* ListDictionary_GetItemValue(wListDictionary* listDictionary, const void* key);
+WINPR_API BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, const void* key,
+ void* value);
WINPR_API wListDictionary* ListDictionary_New(BOOL synchronized);
WINPR_API void ListDictionary_Free(wListDictionary* listDictionary);
return status;
}
-static BOOL thread_compare(void* a, void* b)
+static BOOL thread_compare(const void* a, const void* b)
{
- pthread_t* p1 = a;
- pthread_t* p2 = b;
+ const pthread_t* p1 = a;
+ const pthread_t* p2 = b;
BOOL rc = pthread_equal(*p1, *p2);
return rc;
}
* Gets or sets the number of elements that the ArrayList can contain.
*/
-int ArrayList_Capacity(wArrayList *arrayList)
+int ArrayList_Capacity(wArrayList* arrayList)
{
return arrayList->capacity;
}
* Gets the number of elements actually contained in the ArrayList.
*/
-int ArrayList_Count(wArrayList *arrayList)
+int ArrayList_Count(wArrayList* arrayList)
{
return arrayList->size;
}
* Gets a value indicating whether the ArrayList has a fixed size.
*/
-BOOL ArrayList_IsFixedSized(wArrayList *arrayList)
+BOOL ArrayList_IsFixedSized(wArrayList* arrayList)
{
return FALSE;
}
* Gets a value indicating whether the ArrayList is read-only.
*/
-BOOL ArrayList_IsReadOnly(wArrayList *arrayList)
+BOOL ArrayList_IsReadOnly(wArrayList* arrayList)
{
return FALSE;
}
* Gets a value indicating whether access to the ArrayList is synchronized (thread safe).
*/
-BOOL ArrayList_IsSynchronized(wArrayList *arrayList)
+BOOL ArrayList_IsSynchronized(wArrayList* arrayList)
{
return arrayList->synchronized;
}
* Lock access to the ArrayList
*/
-void ArrayList_Lock(wArrayList *arrayList)
+void ArrayList_Lock(wArrayList* arrayList)
{
EnterCriticalSection(&arrayList->lock);
}
* Unlock access to the ArrayList
*/
-void ArrayList_Unlock(wArrayList *arrayList)
+void ArrayList_Unlock(wArrayList* arrayList)
{
LeaveCriticalSection(&arrayList->lock);
}
* Gets the element at the specified index.
*/
-void *ArrayList_GetItem(wArrayList *arrayList, int index)
+void* ArrayList_GetItem(wArrayList* arrayList, int index)
{
- void *obj = NULL;
+ void* obj = NULL;
if ((index >= 0) && (index < arrayList->size))
{
* Sets the element at the specified index.
*/
-void ArrayList_SetItem(wArrayList *arrayList, int index, void *obj)
+void ArrayList_SetItem(wArrayList* arrayList, int index, void* obj)
{
if ((index >= 0) && (index < arrayList->size))
{
* Shift a section of the list.
*/
-BOOL ArrayList_Shift(wArrayList *arrayList, int index, int count)
+BOOL ArrayList_Shift(wArrayList* arrayList, int index, int count)
{
if (count > 0)
{
if (arrayList->size + count > arrayList->capacity)
{
- void **newArray;
+ void** newArray;
int newCapacity = arrayList->capacity * arrayList->growthFactor;
- newArray = (void **)realloc(arrayList->array, sizeof(void *) * newCapacity);
+ newArray = (void**)realloc(arrayList->array, sizeof(void*) * newCapacity);
if (!newArray)
return FALSE;
arrayList->capacity = newCapacity;
}
- MoveMemory(&arrayList->array[index + count], &arrayList->array[index], (arrayList->size - index) * sizeof(void *));
+ MoveMemory(&arrayList->array[index + count], &arrayList->array[index],
+ (arrayList->size - index) * sizeof(void*));
arrayList->size += count;
}
else if (count < 0)
int chunk = arrayList->size - index + count;
if (chunk > 0)
- MoveMemory(&arrayList->array[index], &arrayList->array[index - count], chunk * sizeof(void *));
+ MoveMemory(&arrayList->array[index], &arrayList->array[index - count], chunk * sizeof(void*));
arrayList->size += count;
}
* Removes all elements from the ArrayList.
*/
-void ArrayList_Clear(wArrayList *arrayList)
+void ArrayList_Clear(wArrayList* arrayList)
{
int index;
* Determines whether an element is in the ArrayList.
*/
-BOOL ArrayList_Contains(wArrayList *arrayList, void *obj)
+BOOL ArrayList_Contains(wArrayList* arrayList, void* obj)
{
int index;
BOOL rc = FALSE;
* Adds an object to the end of the ArrayList.
*/
-int ArrayList_Add(wArrayList *arrayList, void *obj)
+int ArrayList_Add(wArrayList* arrayList, void* obj)
{
int index = -1;
if (arrayList->size + 1 > arrayList->capacity)
{
- void **newArray;
+ void** newArray;
int newCapacity = arrayList->capacity * arrayList->growthFactor;
- newArray = (void **)realloc(arrayList->array, sizeof(void *) * newCapacity);
+ newArray = (void**)realloc(arrayList->array, sizeof(void*) * newCapacity);
if (!newArray)
goto out;
* Inserts an element into the ArrayList at the specified index.
*/
-BOOL ArrayList_Insert(wArrayList *arrayList, int index, void *obj)
+BOOL ArrayList_Insert(wArrayList* arrayList, int index, void* obj)
{
BOOL ret = TRUE;
* Removes the first occurrence of a specific object from the ArrayList.
*/
-BOOL ArrayList_Remove(wArrayList *arrayList, void *obj)
+BOOL ArrayList_Remove(wArrayList* arrayList, void* obj)
{
int index;
BOOL found = FALSE;
* Removes the element at the specified index of the ArrayList.
*/
-BOOL ArrayList_RemoveAt(wArrayList *arrayList, int index)
+BOOL ArrayList_RemoveAt(wArrayList* arrayList, int index)
{
BOOL ret = TRUE;
* in the ArrayList that contains the specified number of elements and ends at the specified index.
*/
-int ArrayList_IndexOf(wArrayList *arrayList, void *obj, int startIndex, int count)
+int ArrayList_IndexOf(wArrayList* arrayList, void* obj, int startIndex, int count)
{
int index;
BOOL found = FALSE;
* in the ArrayList that contains the specified number of elements and ends at the specified index.
*/
-int ArrayList_LastIndexOf(wArrayList *arrayList, void *obj, int startIndex, int count)
+int ArrayList_LastIndexOf(wArrayList* arrayList, void* obj, int startIndex, int count)
{
int index;
BOOL found = FALSE;
return index;
}
-static BOOL ArrayList_DefaultCompare(void *objA, void *objB)
+static BOOL ArrayList_DefaultCompare(const void* objA, const void* objB)
{
return objA == objB ? TRUE : FALSE;
}
* Construction, Destruction
*/
-wArrayList *ArrayList_New(BOOL synchronized)
+wArrayList* ArrayList_New(BOOL synchronized)
{
- wArrayList *arrayList = NULL;
- arrayList = (wArrayList *)calloc(1, sizeof(wArrayList));
+ wArrayList* arrayList = NULL;
+ arrayList = (wArrayList*)calloc(1, sizeof(wArrayList));
if (!arrayList)
return NULL;
arrayList->capacity = 32;
arrayList->growthFactor = 2;
arrayList->object.fnObjectEquals = ArrayList_DefaultCompare;
- arrayList->array = (void **)calloc(arrayList->capacity, sizeof(void *));
+ arrayList->array = (void**)calloc(arrayList->capacity, sizeof(void*));
if (!arrayList->array)
goto out_free;
return NULL;
}
-void ArrayList_Free(wArrayList *arrayList)
+void ArrayList_Free(wArrayList* arrayList)
{
if (!arrayList)
return;
return TRUE;
}
-static BOOL default_equal_function(void* objA, void* objB)
+static BOOL default_equal_function(const void* objA, const void* objB)
{
return objA == objB;
}
if (count)
{
- pKeys = (ULONG_PTR *) calloc(count, sizeof(ULONG_PTR));
+ pKeys = (ULONG_PTR*) calloc(count, sizeof(ULONG_PTR));
+
if (!pKeys)
{
if (listDictionary->synchronized)
* Adds an entry with the specified key and value into the ListDictionary.
*/
-BOOL ListDictionary_Add(wListDictionary* listDictionary, void* key, void* value)
+BOOL ListDictionary_Add(wListDictionary* listDictionary, const void* key, void* value)
{
wListDictionaryItem* item;
wListDictionaryItem* lastItem;
EnterCriticalSection(&listDictionary->lock);
item = (wListDictionaryItem*) malloc(sizeof(wListDictionaryItem));
+
if (!item)
goto out_error;
- item->key = key;
+ item->key = (void*)key;
item->value = value;
-
item->next = NULL;
if (!listDictionary->head)
ret = TRUE;
out_error:
+
if (listDictionary->synchronized)
LeaveCriticalSection(&listDictionary->lock);
* Determines whether the ListDictionary contains a specific key.
*/
-BOOL ListDictionary_Contains(wListDictionary* listDictionary, void* key)
+BOOL ListDictionary_Contains(wListDictionary* listDictionary, const void* key)
{
wListDictionaryItem* item;
OBJECT_EQUALS_FN keyEquals;
* Removes the entry with the specified key from the ListDictionary.
*/
-void* ListDictionary_Remove(wListDictionary* listDictionary, void* key)
+void* ListDictionary_Remove(wListDictionary* listDictionary, const void* key)
{
void* value = NULL;
wListDictionaryItem* item;
EnterCriticalSection(&listDictionary->lock);
keyEquals = listDictionary->objectKey.fnObjectEquals;
-
item = listDictionary->head;
prevItem = NULL;
listDictionary->head = item->next;
else
prevItem->next = item->next;
+
value = item->value;
free(item);
break;
* Removes the first (head) entry from the list
*/
-void *ListDictionary_Remove_Head(wListDictionary* listDictionary)
+void* ListDictionary_Remove_Head(wListDictionary* listDictionary)
{
wListDictionaryItem* item;
- void *value = NULL;
+ void* value = NULL;
if (!listDictionary)
return NULL;
if (listDictionary->synchronized)
LeaveCriticalSection(&listDictionary->lock);
+
return value;
}
* Get an item value using key
*/
-void* ListDictionary_GetItemValue(wListDictionary* listDictionary, void* key)
+void* ListDictionary_GetItemValue(wListDictionary* listDictionary, const void* key)
{
void* value = NULL;
wListDictionaryItem* item = NULL;
* Set an item value using key
*/
-BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, void* key, void* value)
+BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, const void* key, void* value)
{
BOOL status = FALSE;
wListDictionaryItem* item;
EnterCriticalSection(&listDictionary->lock);
keyEquals = listDictionary->objectKey.fnObjectEquals;
+
if (listDictionary->head)
{
item = listDictionary->head;
{
if (listDictionary->objectValue.fnObjectFree)
listDictionary->objectValue.fnObjectFree(item->value);
+
item->value = value;
}
return status;
}
-static BOOL default_equal_function(void *obj1, void *obj2)
+static BOOL default_equal_function(const void* obj1, const void* obj2)
{
return (obj1 == obj2);
}
wListDictionary* ListDictionary_New(BOOL synchronized)
{
wListDictionary* listDictionary = NULL;
-
listDictionary = (wListDictionary*) calloc(1, sizeof(wListDictionary));
if (!listDictionary)
listDictionary->objectKey.fnObjectEquals = default_equal_function;
listDictionary->objectValue.fnObjectEquals = default_equal_function;
-
return listDictionary;
}
int Queue_Count(wQueue* queue)
{
int ret;
+
if (queue->synchronized)
EnterCriticalSection(&queue->lock);
if (queue->synchronized)
LeaveCriticalSection(&queue->lock);
+
return ret;
}
{
int old_capacity;
int new_capacity;
- void **newArray;
-
+ void** newArray;
old_capacity = queue->capacity;
new_capacity = queue->capacity * queue->growthFactor;
+ newArray = (void**)realloc(queue->array, sizeof(void*) * new_capacity);
- newArray = (void **)realloc(queue->array, sizeof(void*) * new_capacity);
if (!newArray)
{
ret = FALSE;
queue->array[queue->tail] = obj;
queue->tail = (queue->tail + 1) % queue->capacity;
queue->size++;
-
SetEvent(queue->event);
-
out:
+
if (queue->synchronized)
LeaveCriticalSection(&queue->lock);
+
return ret;
}
return obj;
}
-static BOOL default_queue_equals(void *obj1, void *obj2)
+static BOOL default_queue_equals(const void* obj1, const void* obj2)
{
return (obj1 == obj2);
}
wQueue* Queue_New(BOOL synchronized, int capacity, int growthFactor)
{
wQueue* queue = NULL;
+ queue = (wQueue*)calloc(1, sizeof(wQueue));
- queue = (wQueue *)calloc(1, sizeof(wQueue));
if (!queue)
return NULL;
queue->capacity = 32;
queue->growthFactor = 2;
-
queue->synchronized = synchronized;
if (capacity > 0)
if (growthFactor > 0)
queue->growthFactor = growthFactor;
- queue->array = (void **)calloc(queue->capacity, sizeof(void *));
+ queue->array = (void**)calloc(queue->capacity, sizeof(void*));
+
if (!queue->array)
goto out_free;
queue->event = CreateEvent(NULL, TRUE, FALSE, NULL);
+
if (!queue->event)
goto out_free_array;
queue->object.fnObjectEquals = default_queue_equals;
return queue;
-
out_free_event:
CloseHandle(queue->event);
out_free_array:
return;
Queue_Clear(queue);
-
CloseHandle(queue->event);
DeleteCriticalSection(&queue->lock);
free(queue->array);
if ((stack->size + 1) >= stack->capacity)
{
int new_cap;
- void **new_arr;
-
+ void** new_arr;
new_cap = stack->capacity * 2;
new_arr = (void**) realloc(stack->array, sizeof(void*) * new_cap);
+
if (!new_arr)
return;
+
stack->array = new_arr;
stack->capacity = new_cap;
}
}
-static BOOL default_stack_equals(void *obj1, void *obj2)
+static BOOL default_stack_equals(const void* obj1, const void* obj2)
{
return (obj1 == obj2);
}
wStack* Stack_New(BOOL synchronized)
{
wStack* stack = NULL;
+ stack = (wStack*)calloc(1, sizeof(wStack));
- stack = (wStack *)calloc(1, sizeof(wStack));
if (!stack)
return NULL;
stack->object.fnObjectEquals = default_stack_equals;
stack->synchronized = synchronized;
-
stack->capacity = 32;
stack->array = (void**) calloc(stack->capacity, sizeof(void*));
+
if (!stack->array)
goto out_free;
if (stack->synchronized && !InitializeCriticalSectionAndSpinCount(&stack->lock, 4000))
- goto out_free_array;
+ goto out_free_array;
return stack;
-
out_free_array:
free(stack->array);
out_free:
DeleteCriticalSection(&stack->lock);
free(stack->array);
-
free(stack);
}
}
projects / platform / upstream / freerdp.git / commitdiff