diff --git a/winpr/include/winpr/collections.h b/winpr/include/winpr/collections.h new file mode 100644 index 000000000..085f904cd --- /dev/null +++ b/winpr/include/winpr/collections.h @@ -0,0 +1,104 @@ +/** + * WinPR: Windows Portable Runtime + * Collections + * + * Copyright 2012 Marc-Andre Moreau + * + * 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. + */ + +#ifndef WINPR_COLLECTIONS_H +#define WINPR_COLLECTIONS_H + +#include +#include +#include + +#include +#include + +/* System.Collections.Queue */ + +struct _wQueue +{ + BOOL bSynchronized; +}; +typedef struct _wQueue wQueue; + +WINPR_API int Queue_Count(wQueue* queue); +WINPR_API BOOL Queue_IsSynchronized(wQueue* queue); + +WINPR_API void Queue_Clear(wQueue* queue); +WINPR_API BOOL Queue_Contains(wQueue* queue, void* obj); + +WINPR_API void Queue_Enqueue(wQueue* queue, void* obj); +WINPR_API void* Queue_Dequeue(wQueue* queue); + +WINPR_API void* Queue_Peek(wQueue* queue); + +WINPR_API wQueue* Queue_New(BOOL bSynchronized); +WINPR_API void Queue_Free(wQueue* queue); + +/* System.Collections.Stack */ + +struct _wStack +{ + BOOL bSynchronized; +}; +typedef struct _wStack wStack; + +WINPR_API int Stack_Count(wStack* stack); +WINPR_API BOOL Stack_IsSynchronized(wStack* stack); + +WINPR_API void Stack_Clear(wStack* stack); +WINPR_API BOOL Stack_Contains(wStack* stack, void* obj); + +WINPR_API void Stack_Push(wStack* stack, void* obj); +WINPR_API void* Stack_Pop(wStack* stack); + +WINPR_API void* Stack_Peek(wStack* stack); + +WINPR_API wStack* Stack_New(BOOL bSynchronized); +WINPR_API void Stack_Free(wStack* stack); + +/* System.Collections.ArrayList */ + +struct _wArrayList +{ + BOOL bSynchronized; +}; +typedef struct _wArrayList wArrayList; + +WINPR_API int ArrayList_Capacity(wArrayList* arrayList); +WINPR_API int ArrayList_Count(wArrayList* arrayList); +WINPR_API BOOL ArrayList_IsFixedSized(wArrayList* arrayList); +WINPR_API BOOL ArrayList_IsReadOnly(wArrayList* arrayList); +WINPR_API BOOL ArrayList_IsSynchronized(wArrayList* arrayList); +WINPR_API void* ArrayList_Item(wArrayList* arrayList, int index, void* obj); + +WINPR_API void ArrayList_Clear(wArrayList* arrayList); +WINPR_API BOOL ArrayList_Contains(wArrayList* arrayList, void* obj); + +WINPR_API int ArrayList_Add(wArrayList* arrayList, void* obj); +WINPR_API void ArrayList_Insert(wArrayList* arrayList, int index, void* obj); + +WINPR_API void ArrayList_Remove(wArrayList* arrayList, void* obj); +WINPR_API void ArrayList_RemoveAt(wArrayList* arrayList, int index, void* obj); + +WINPR_API int ArrayList_IndexOf(wArrayList* arrayList, void* obj, int startIndex, int count); +WINPR_API int ArrayList_LastIndexOf(wArrayList* arrayList, void* obj, int startIndex, int count); + +WINPR_API wArrayList* ArrayList_New(BOOL bSynchronized); +WINPR_API void ArrayList_Free(wArrayList* arrayList); + +#endif /* WINPR_COLLECTIONS_H */ diff --git a/winpr/libwinpr/utils/CMakeLists.txt b/winpr/libwinpr/utils/CMakeLists.txt index 4e40e2b7f..55d83fdad 100644 --- a/winpr/libwinpr/utils/CMakeLists.txt +++ b/winpr/libwinpr/utils/CMakeLists.txt @@ -18,6 +18,11 @@ set(MODULE_NAME "winpr-utils") set(MODULE_PREFIX "WINPR_UTILS") +set(${MODULE_PREFIX}_COLLECTIONS_SRCS + collections/Queue.c + collections/Stack.c + collections/ArrayList.c) + set(${MODULE_PREFIX}_SRCS sam.c ntlm.c @@ -25,6 +30,9 @@ set(${MODULE_PREFIX}_SRCS stream.c cmdline.c) +set(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_SRCS} + ${${MODULE_PREFIX}_COLLECTIONS_SRCS}) + include_directories(${ZLIB_INCLUDE_DIRS}) include_directories(${OPENSSL_INCLUDE_DIR}) diff --git a/winpr/libwinpr/utils/collections/ArrayList.c b/winpr/libwinpr/utils/collections/ArrayList.c new file mode 100644 index 000000000..a00ec1ec3 --- /dev/null +++ b/winpr/libwinpr/utils/collections/ArrayList.c @@ -0,0 +1,240 @@ +/** + * WinPR: Windows Portable Runtime + * System.Collections.ArrayList + * + * Copyright 2012 Marc-Andre Moreau + * + * 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 + +/** + * C equivalent of the C# ArrayList Class: + * http://msdn.microsoft.com/en-us/library/system.collections.arraylist.aspx + */ + +/** + * Properties + */ + +/** + * Gets or sets the number of elements that the ArrayList can contain. + */ + +int ArrayList_Capacity(wArrayList* arrayList) +{ + if (arrayList->bSynchronized) + { + + } + + return 0; +} + +/** + * Gets the number of elements actually contained in the ArrayList. + */ + +int ArrayList_Count(wArrayList* arrayList) +{ + if (arrayList->bSynchronized) + { + + } + + return 0; +} + +/** + * Gets a value indicating whether the ArrayList has a fixed size. + */ + +BOOL ArrayList_IsFixedSized(wArrayList* arrayList) +{ + return FALSE; +} + +/** + * Gets a value indicating whether the ArrayList is read-only. + */ + +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) +{ + return arrayList->bSynchronized; +} + +/** + * Gets or sets the element at the specified index. + */ + +void* ArrayList_Item(wArrayList* arrayList, int index, void* obj) +{ + return NULL; +} + +/** + * Methods + */ + +/** + * Removes all elements from the ArrayList. + */ + +void ArrayList_Clear(wArrayList* arrayList) +{ + if (arrayList->bSynchronized) + { + + } +} + +/** + * Determines whether an element is in the ArrayList. + */ + +BOOL ArrayList_Contains(wArrayList* arrayList, void* obj) +{ + if (arrayList->bSynchronized) + { + + } + + return FALSE; +} + +/** + * Adds an object to the end of the ArrayList. + */ + +int ArrayList_Add(wArrayList* arrayList, void* obj) +{ + if (arrayList->bSynchronized) + { + + } + + return FALSE; +} + +/* + * Inserts an element into the ArrayList at the specified index. + */ + +void ArrayList_Insert(wArrayList* arrayList, int index, void* obj) +{ + if (arrayList->bSynchronized) + { + + } +} + +/** + * Removes the first occurrence of a specific object from the ArrayList. + */ + +void ArrayList_Remove(wArrayList* arrayList, void* obj) +{ + if (arrayList->bSynchronized) + { + + } +} + +/** + * Removes the element at the specified index of the ArrayList. + */ + +void ArrayList_RemoveAt(wArrayList* arrayList, int index, void* obj) +{ + if (arrayList->bSynchronized) + { + + } +} + +/** + * Searches for the specified Object and returns the zero-based index of the first occurrence within the entire ArrayList. + * + * Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements + * in the ArrayList that extends from the first element to the specified index. + * + * Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements + * 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) +{ + if (arrayList->bSynchronized) + { + + } + + return 0; +} + +/** + * Searches for the specified Object and returns the zero-based index of the last occurrence within the entire ArrayList. + * + * Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements + * in the ArrayList that extends from the first element to the specified index. + * + * Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements + * 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) +{ + if (arrayList->bSynchronized) + { + + } + + return 0; +} + +/** + * Construction, Destruction + */ + +wArrayList* ArrayList_New(BOOL bSynchronized) +{ + wArrayList* arrayList = NULL; + + arrayList = (wArrayList*) malloc(sizeof(wArrayList)); + + if (arrayList) + { + arrayList->bSynchronized = bSynchronized; + } + + return arrayList; +} + +void ArrayList_Free(wArrayList* arrayList) +{ + free(arrayList); +} diff --git a/winpr/libwinpr/utils/collections/Queue.c b/winpr/libwinpr/utils/collections/Queue.c new file mode 100644 index 000000000..a744287ff --- /dev/null +++ b/winpr/libwinpr/utils/collections/Queue.c @@ -0,0 +1,149 @@ +/** + * WinPR: Windows Portable Runtime + * System.Collections.Queue + * + * Copyright 2012 Marc-Andre Moreau + * + * 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 + +/** + * C equivalent of the C# Queue Class: + * http://msdn.microsoft.com/en-us/library/system.collections.queue.aspx + */ + +/** + * Properties + */ + +/** + * Gets the number of elements contained in the Queue. + */ + +int Queue_Count(wQueue* queue) +{ + if (queue->bSynchronized) + { + + } + + return 0; +} + +/** + * Gets a value indicating whether access to the Queue is synchronized (thread safe). + */ + +BOOL Queue_IsSynchronized(wQueue* queue) +{ + return queue->bSynchronized; +} + +/** + * Methods + */ + +/** + * Removes all objects from the Queue. + */ + +void Queue_Clear(wQueue* queue) +{ + if (queue->bSynchronized) + { + + } +} + +/** + * Determines whether an element is in the Queue. + */ + +BOOL Queue_Contains(wQueue* queue, void* obj) +{ + if (queue->bSynchronized) + { + + } + + return FALSE; +} + +/** + * Adds an object to the end of the Queue. + */ + +void Queue_Enqueue(wQueue* queue, void* obj) +{ + if (queue->bSynchronized) + { + + } +} + +/** + * Removes and returns the object at the beginning of the Queue. + */ + +void* Queue_Dequeue(wQueue* queue) +{ + if (queue->bSynchronized) + { + + } + + return NULL; +} + +/** + * Returns the object at the beginning of the Queue without removing it. + */ + +void* Queue_Peek(wQueue* queue) +{ + if (queue->bSynchronized) + { + + } + + return NULL; +} + +/** + * Construction, Destruction + */ + +wQueue* Queue_New(BOOL bSynchronized) +{ + wQueue* queue = NULL; + + queue = (wQueue*) malloc(sizeof(wQueue)); + + if (queue) + { + queue->bSynchronized = bSynchronized; + } + + return queue; +} + +void Queue_Free(wQueue* queue) +{ + free(queue); +} diff --git a/winpr/libwinpr/utils/collections/Stack.c b/winpr/libwinpr/utils/collections/Stack.c new file mode 100644 index 000000000..464a33570 --- /dev/null +++ b/winpr/libwinpr/utils/collections/Stack.c @@ -0,0 +1,149 @@ +/** + * WinPR: Windows Portable Runtime + * System.Collections.Stack + * + * Copyright 2012 Marc-Andre Moreau + * + * 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 + +/** + * 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) +{ + if (stack->bSynchronized) + { + + } + + return 0; +} + +/** + * Gets a value indicating whether access to the Stack is synchronized (thread safe). + */ + +BOOL Stack_IsSynchronized(wStack* stack) +{ + return stack->bSynchronized; +} + +/** + * Methods + */ + +/** + * Removes all objects from the Stack. + */ + +void Stack_Clear(wStack* stack) +{ + if (stack->bSynchronized) + { + + } +} + +/** + * Determines whether an element is in the Stack. + */ + +BOOL Stack_Contains(wStack* stack, void* obj) +{ + if (stack->bSynchronized) + { + + } + + return FALSE; +} + +/** + * Inserts an object at the top of the Stack. + */ + +void Stack_Push(wStack* stack, void* obj) +{ + if (stack->bSynchronized) + { + + } +} + +/** + * Removes and returns the object at the top of the Stack. + */ + +void* Stack_Pop(wStack* stack) +{ + if (stack->bSynchronized) + { + + } + + return NULL; +} + +/** + * Returns the object at the top of the Stack without removing it. + */ + +void* Stack_Peek(wStack* stack) +{ + if (stack->bSynchronized) + { + + } + + return NULL; +} + +/** + * Construction, Destruction + */ + +wStack* Stack_New(BOOL bSynchronized) +{ + wStack* stack = NULL; + + stack = (wStack*) malloc(sizeof(wStack)); + + if (stack) + { + stack->bSynchronized = bSynchronized; + } + + return stack; +} + +void Stack_Free(wStack* stack) +{ + free(stack); +}