FreeRDP/winpr/libwinpr/utils/collections/Stack.c

237 lines
4.2 KiB
C
Raw Normal View History

/**
* WinPR: Windows Portable Runtime
* System.Collections.Stack
*
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <winpr/collections.h>
/**
* C equivalent of the C# Stack Class:
* http://msdn.microsoft.com/en-us/library/system.collections.stack.aspx
*/
/**
* Properties
*/
/**
* Gets the number of elements contained in the Stack.
*/
int Stack_Count(wStack* stack)
{
int ret;
2012-12-06 02:24:01 +04:00
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
ret = stack->size;
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
return ret;
}
/**
* Gets a value indicating whether access to the Stack is synchronized (thread safe).
*/
BOOL Stack_IsSynchronized(wStack* stack)
{
2012-12-06 02:24:01 +04:00
return stack->synchronized;
}
/**
* Methods
*/
/**
* Removes all objects from the Stack.
*/
void Stack_Clear(wStack* stack)
{
int index;
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
for (index = 0; index < stack->size; index++)
{
if (stack->object.fnObjectFree)
stack->object.fnObjectFree(stack->array[index]);
stack->array[index] = NULL;
}
stack->size = 0;
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
}
/**
* Determines whether an element is in the Stack.
*/
BOOL Stack_Contains(wStack* stack, void* obj)
{
int i;
BOOL found = FALSE;
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
for (i = 0; i < stack->size; i++)
{
if (stack->object.fnObjectEquals(stack->array[i], obj))
{
found = TRUE;
break;
}
}
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
return found;
}
/**
* Inserts an object at the top of the Stack.
*/
void Stack_Push(wStack* stack, void* obj)
{
2012-12-06 02:24:01 +04:00
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
if ((stack->size + 1) >= stack->capacity)
{
int new_cap;
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;
}
stack->array[(stack->size)++] = obj;
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
}
/**
* Removes and returns the object at the top of the Stack.
*/
void* Stack_Pop(wStack* stack)
{
void* obj = NULL;
2012-12-06 02:24:01 +04:00
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
if (stack->size > 0)
obj = stack->array[--(stack->size)];
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
return obj;
}
/**
* Returns the object at the top of the Stack without removing it.
*/
void* Stack_Peek(wStack* stack)
{
void* obj = NULL;
2012-12-06 02:24:01 +04:00
if (stack->synchronized)
EnterCriticalSection(&stack->lock);
if (stack->size > 0)
obj = stack->array[stack->size];
if (stack->synchronized)
LeaveCriticalSection(&stack->lock);
return obj;
}
static BOOL default_stack_equals(void *obj1, void *obj2)
{
return (obj1 == obj2);
}
/**
* Construction, Destruction
*/
wStack* Stack_New(BOOL synchronized)
{
wStack* stack = NULL;
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**) malloc(sizeof(void*) * stack->capacity);
if (!stack->array)
goto out_free;
if (stack->synchronized && !InitializeCriticalSectionAndSpinCount(&stack->lock, 4000))
goto out_free_array;
return stack;
out_free_array:
free(stack->array);
out_free:
free(stack);
return NULL;
}
void Stack_Free(wStack* stack)
{
2014-11-16 18:48:50 +03:00
if (stack)
{
if (stack->synchronized)
DeleteCriticalSection(&stack->lock);
free(stack->array);
free(stack);
}
}