collections.h

 
#ifndef WINPR_COLLECTIONS_H
#define WINPR_COLLECTIONS_H
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
 
#include <winpr/winpr.h>
#include <winpr/wtypes.h>
#include <winpr/assert.h>
 
#include <winpr/crt.h>
#include <winpr/synch.h>
#include <winpr/stream.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  typedef void* (*OBJECT_NEW_FN)(const void* val);
  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)(const void* objA, const void* objB);
 
  typedef struct
  {
    OBJECT_NEW_FN fnObjectNew;
    OBJECT_INIT_FN fnObjectInit;
    OBJECT_UNINIT_FN fnObjectUninit;
    OBJECT_FREE_FN fnObjectFree;
    OBJECT_EQUALS_FN fnObjectEquals;
  } wObject;
 
  /* utility function with compatible arguments for string data */
 
  WINPR_API void* winpr_ObjectStringClone(const void* pvstr);
 
  WINPR_API void* winpr_ObjectWStringClone(const void* pvstr);
 
  WINPR_API void winpr_ObjectStringFree(void* pvstr);
 
  /* System.Collections.Queue */
 
  typedef struct s_wQueue wQueue;
 
  WINPR_API size_t Queue_Count(wQueue* queue);
 
  WINPR_API void Queue_Lock(wQueue* queue);
 
  WINPR_API void Queue_Unlock(wQueue* queue);
 
  WINPR_API HANDLE Queue_Event(wQueue* queue);
 
  WINPR_API wObject* Queue_Object(wQueue* queue);
 
  WINPR_API void Queue_Clear(wQueue* queue);
 
  WINPR_API BOOL Queue_Contains(wQueue* queue, const void* obj);
 
  WINPR_API BOOL Queue_Enqueue(wQueue* queue, const void* obj);
 
  WINPR_API void* Queue_Dequeue(wQueue* queue);
 
  WINPR_API void* Queue_Peek(wQueue* queue);
 
  WINPR_API void Queue_Discard(wQueue* queue);
 
  WINPR_API void Queue_Free(wQueue* queue);
 
  WINPR_ATTR_MALLOC(Queue_Free, 1)
  WINPR_API wQueue* Queue_New(BOOL synchronized, SSIZE_T capacity, SSIZE_T growthFactor);
 
  /* System.Collections.Stack */
 
  typedef struct s_wStack wStack;
 
  WINPR_API size_t Stack_Count(wStack* stack);
  WINPR_API BOOL Stack_IsSynchronized(wStack* stack);
 
  WINPR_API wObject* Stack_Object(wStack* stack);
 
  WINPR_API void Stack_Clear(wStack* stack);
  WINPR_API BOOL Stack_Contains(wStack* stack, const 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 void Stack_Free(wStack* stack);
 
  WINPR_ATTR_MALLOC(Stack_Free, 1)
  WINPR_API wStack* Stack_New(BOOL synchronized);
 
  /* System.Collections.ArrayList */
 
  typedef struct s_wArrayList wArrayList;
 
  WINPR_API size_t ArrayList_Capacity(wArrayList* arrayList);
  WINPR_API size_t ArrayList_Count(wArrayList* arrayList);
  WINPR_API size_t ArrayList_Items(wArrayList* arrayList, ULONG_PTR** ppItems);
  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_Lock(wArrayList* arrayList);
  WINPR_API void ArrayList_Unlock(wArrayList* arrayList);
 
  WINPR_API void* ArrayList_GetItem(wArrayList* arrayList, size_t index);
  WINPR_API BOOL ArrayList_SetItem(wArrayList* arrayList, size_t index, const void* obj);
 
  WINPR_API wObject* ArrayList_Object(wArrayList* arrayList);
 
  typedef BOOL (*ArrayList_ForEachFkt)(void* data, size_t index, va_list ap);
 
  WINPR_API BOOL ArrayList_ForEach(wArrayList* arrayList, ArrayList_ForEachFkt fkt, ...);
  WINPR_API BOOL ArrayList_ForEachAP(wArrayList* arrayList, ArrayList_ForEachFkt fkt, va_list ap);
 
  WINPR_API void ArrayList_Clear(wArrayList* arrayList);
  WINPR_API BOOL ArrayList_Contains(wArrayList* arrayList, const void* obj);
 
#if defined(WITH_WINPR_DEPRECATED)
  WINPR_API WINPR_DEPRECATED(int ArrayList_Add(wArrayList* arrayList, const void* obj));
#endif
 
  WINPR_API BOOL ArrayList_Append(wArrayList* arrayList, const void* obj);
  WINPR_API BOOL ArrayList_Insert(wArrayList* arrayList, size_t index, const void* obj);
 
  WINPR_API BOOL ArrayList_Remove(wArrayList* arrayList, const void* obj);
  WINPR_API BOOL ArrayList_RemoveAt(wArrayList* arrayList, size_t index);
 
  WINPR_API SSIZE_T ArrayList_IndexOf(wArrayList* arrayList, const void* obj, SSIZE_T startIndex,
                                      SSIZE_T count);
  WINPR_API SSIZE_T ArrayList_LastIndexOf(wArrayList* arrayList, const void* obj,
                                          SSIZE_T startIndex, SSIZE_T count);
 
  WINPR_API void ArrayList_Free(wArrayList* arrayList);
 
  WINPR_ATTR_MALLOC(ArrayList_Free, 1)
  WINPR_API wArrayList* ArrayList_New(BOOL synchronized);
 
  /* System.Collections.DictionaryBase */
 
  /* System.Collections.Specialized.ListDictionary */
  typedef struct s_wListDictionary wListDictionary;
 
  WINPR_API wObject* ListDictionary_KeyObject(wListDictionary* listDictionary);
 
  WINPR_API wObject* ListDictionary_ValueObject(wListDictionary* listDictionary);
 
  WINPR_API size_t ListDictionary_Count(wListDictionary* listDictionary);
 
  WINPR_API void ListDictionary_Lock(wListDictionary* listDictionary);
  WINPR_API void ListDictionary_Unlock(wListDictionary* listDictionary);
 
  WINPR_API BOOL ListDictionary_Add(wListDictionary* listDictionary, const void* key,
                                    const void* value);
 
  WINPR_API void* ListDictionary_Take(wListDictionary* listDictionary, const void* key);
 
  WINPR_API void ListDictionary_Remove(wListDictionary* listDictionary, const void* key);
 
  WINPR_API void* ListDictionary_Take_Head(wListDictionary* listDictionary);
 
  WINPR_API void ListDictionary_Remove_Head(wListDictionary* listDictionary);
 
  WINPR_API void ListDictionary_Clear(wListDictionary* listDictionary);
 
  WINPR_API BOOL ListDictionary_Contains(wListDictionary* listDictionary, const void* key);
 
  WINPR_API size_t ListDictionary_GetKeys(wListDictionary* listDictionary, ULONG_PTR** ppKeys);
 
  WINPR_API void* ListDictionary_GetItemValue(wListDictionary* listDictionary, const void* key);
 
  WINPR_API BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, const void* key,
                                             const void* value);
 
  WINPR_API void ListDictionary_Free(wListDictionary* listDictionary);
 
  WINPR_ATTR_MALLOC(ListDictionary_Free, 1)
  WINPR_API wListDictionary* ListDictionary_New(BOOL synchronized);
 
  /* System.Collections.Generic.LinkedList<T> */
 
  typedef struct s_wLinkedList wLinkedList;
 
  WINPR_API size_t LinkedList_Count(wLinkedList* list);
 
  WINPR_API void* LinkedList_First(wLinkedList* list);
 
  WINPR_API void* LinkedList_Last(wLinkedList* list);
 
  WINPR_API BOOL LinkedList_Contains(wLinkedList* list, const void* value);
 
  WINPR_API void LinkedList_Clear(wLinkedList* list);
 
  WINPR_API BOOL LinkedList_AddFirst(wLinkedList* list, const void* value);
 
  WINPR_API BOOL LinkedList_AddLast(wLinkedList* list, const void* value);
 
  WINPR_API BOOL LinkedList_Remove(wLinkedList* list, const void* value);
 
  WINPR_API void LinkedList_RemoveFirst(wLinkedList* list);
 
  WINPR_API void LinkedList_RemoveLast(wLinkedList* list);
 
  WINPR_API void LinkedList_Enumerator_Reset(wLinkedList* list);
 
  WINPR_API void* LinkedList_Enumerator_Current(wLinkedList* list);
 
  WINPR_API BOOL LinkedList_Enumerator_MoveNext(wLinkedList* list);
 
  WINPR_API void LinkedList_Free(wLinkedList* list);
 
  WINPR_ATTR_MALLOC(LinkedList_Free, 1)
  WINPR_API wLinkedList* LinkedList_New(void);
 
  WINPR_API wObject* LinkedList_Object(wLinkedList* list);
 
  /* System.Collections.Generic.KeyValuePair<TKey,TValue> */
 
  /* Countdown Event */
 
  typedef struct CountdownEvent wCountdownEvent;
 
  WINPR_API size_t CountdownEvent_CurrentCount(wCountdownEvent* countdown);
 
  WINPR_API size_t CountdownEvent_InitialCount(wCountdownEvent* countdown);
 
  WINPR_API BOOL CountdownEvent_IsSet(wCountdownEvent* countdown);
 
  WINPR_API HANDLE CountdownEvent_WaitHandle(wCountdownEvent* countdown);
 
  WINPR_API void CountdownEvent_AddCount(wCountdownEvent* countdown, size_t signalCount);
 
  WINPR_API BOOL CountdownEvent_Signal(wCountdownEvent* countdown, size_t signalCount);
 
  WINPR_API void CountdownEvent_Reset(wCountdownEvent* countdown, size_t count);
 
  WINPR_API void CountdownEvent_Free(wCountdownEvent* countdown);
 
  WINPR_ATTR_MALLOC(CountdownEvent_Free, 1)
  WINPR_API wCountdownEvent* CountdownEvent_New(size_t initialCount);
 
  /* Hash Table */
 
  typedef UINT32 (*HASH_TABLE_HASH_FN)(const void* key);
 
  typedef struct s_wHashTable wHashTable;
 
  typedef BOOL (*HASH_TABLE_FOREACH_FN)(const void* key, void* value, void* arg);
 
  WINPR_API size_t HashTable_Count(wHashTable* table);
 
#if defined(WITH_WINPR_DEPRECATED)
  WINPR_API WINPR_DEPRECATED(int HashTable_Add(wHashTable* table, const void* key,
                                               const void* value));
#endif
 
  WINPR_API BOOL HashTable_Insert(wHashTable* table, const void* key, const void* value);
  WINPR_API BOOL HashTable_Remove(wHashTable* table, const void* key);
  WINPR_API void HashTable_Clear(wHashTable* table);
  WINPR_API BOOL HashTable_Contains(wHashTable* table, const void* key);
  WINPR_API BOOL HashTable_ContainsKey(wHashTable* table, const void* key);
  WINPR_API BOOL HashTable_ContainsValue(wHashTable* table, const void* value);
  WINPR_API void* HashTable_GetItemValue(wHashTable* table, const void* key);
  WINPR_API BOOL HashTable_SetItemValue(wHashTable* table, const void* key, const void* value);
  WINPR_API size_t HashTable_GetKeys(wHashTable* table, ULONG_PTR** ppKeys);
  WINPR_API BOOL HashTable_Foreach(wHashTable* table, HASH_TABLE_FOREACH_FN fn, VOID* arg);
 
  WINPR_API UINT32 HashTable_PointerHash(const void* pointer);
  WINPR_API BOOL HashTable_PointerCompare(const void* pointer1, const void* pointer2);
 
  WINPR_API UINT32 HashTable_StringHash(const void* key);
  WINPR_API BOOL HashTable_StringCompare(const void* string1, const void* string2);
  WINPR_API void* HashTable_StringClone(const void* str);
  WINPR_API void HashTable_StringFree(void* str);
 
  WINPR_API void HashTable_Free(wHashTable* table);
 
  WINPR_ATTR_MALLOC(HashTable_Free, 1)
  WINPR_API wHashTable* HashTable_New(BOOL synchronized);
 
  WINPR_API void HashTable_Lock(wHashTable* table);
  WINPR_API void HashTable_Unlock(wHashTable* table);
 
  WINPR_API wObject* HashTable_KeyObject(wHashTable* table);
  WINPR_API wObject* HashTable_ValueObject(wHashTable* table);
 
  WINPR_API BOOL HashTable_SetHashFunction(wHashTable* table, HASH_TABLE_HASH_FN fn);
 
  /* Utility function to setup hash table for strings */
  WINPR_API BOOL HashTable_SetupForStringData(wHashTable* table, BOOL stringValues);
 
  /* BufferPool */
 
  typedef struct s_wBufferPool wBufferPool;
 
  WINPR_API SSIZE_T BufferPool_GetPoolSize(wBufferPool* pool);
  WINPR_API SSIZE_T BufferPool_GetBufferSize(wBufferPool* pool, const void* buffer);
 
  WINPR_API void* BufferPool_Take(wBufferPool* pool, SSIZE_T bufferSize);
  WINPR_API BOOL BufferPool_Return(wBufferPool* pool, void* buffer);
  WINPR_API void BufferPool_Clear(wBufferPool* pool);
 
  WINPR_API void BufferPool_Free(wBufferPool* pool);
 
  WINPR_ATTR_MALLOC(BufferPool_Free, 1)
  WINPR_API wBufferPool* BufferPool_New(BOOL synchronized, SSIZE_T fixedSize, DWORD alignment);
 
  /* ObjectPool */
 
  typedef struct s_wObjectPool wObjectPool;
 
  WINPR_API void* ObjectPool_Take(wObjectPool* pool);
  WINPR_API void ObjectPool_Return(wObjectPool* pool, void* obj);
  WINPR_API void ObjectPool_Clear(wObjectPool* pool);
 
  WINPR_API wObject* ObjectPool_Object(wObjectPool* pool);
 
  WINPR_API void ObjectPool_Free(wObjectPool* pool);
 
  WINPR_ATTR_MALLOC(ObjectPool_Free, 1)
  WINPR_API wObjectPool* ObjectPool_New(BOOL synchronized);
 
  /* Message Queue */
 
  typedef struct s_wMessage wMessage;
 
  typedef void (*MESSAGE_FREE_FN)(wMessage* message);
 
  struct s_wMessage
  {
    UINT32 id;
    void* context;
    void* wParam;
    void* lParam;
    UINT64 time;
    MESSAGE_FREE_FN Free;
  };
 
  typedef struct s_wMessageQueue wMessageQueue;
 
#define WMQ_QUIT 0xFFFFFFFF
 
  WINPR_API wObject* MessageQueue_Object(wMessageQueue* queue);
  WINPR_API HANDLE MessageQueue_Event(wMessageQueue* queue);
  WINPR_API BOOL MessageQueue_Wait(wMessageQueue* queue);
  WINPR_API size_t MessageQueue_Size(wMessageQueue* queue);
 
  WINPR_API BOOL MessageQueue_Dispatch(wMessageQueue* queue, const wMessage* message);
  WINPR_API BOOL MessageQueue_Post(wMessageQueue* queue, void* context, UINT32 type, void* wParam,
                                   void* lParam);
  WINPR_API BOOL MessageQueue_PostQuit(wMessageQueue* queue, int nExitCode);
 
  WINPR_API int MessageQueue_Get(wMessageQueue* queue, wMessage* message);
  WINPR_API int MessageQueue_Peek(wMessageQueue* queue, wMessage* message, BOOL remove);
 
  WINPR_API int MessageQueue_Clear(wMessageQueue* queue);
 
  WINPR_API void MessageQueue_Free(wMessageQueue* queue);
 
  WINPR_ATTR_MALLOC(MessageQueue_Free, 1)
  WINPR_API wMessageQueue* MessageQueue_New(const wObject* callback);
 
  /* Message Pipe */
 
  typedef struct
  {
    wMessageQueue* In;
    wMessageQueue* Out;
  } wMessagePipe;
 
  WINPR_API void MessagePipe_PostQuit(wMessagePipe* pipe, int nExitCode);
 
  WINPR_API void MessagePipe_Free(wMessagePipe* pipe);
 
  WINPR_ATTR_MALLOC(MessagePipe_Free, 1)
  WINPR_API wMessagePipe* MessagePipe_New(void);
 
  /* Publisher/Subscriber Pattern */
 
  typedef struct
  {
    DWORD Size;
    const char* Sender;
  } wEventArgs;
 
  typedef void (*pEventHandler)(void* context, const wEventArgs* e);
 
#ifdef __cplusplus
#define WINPR_EVENT_CAST(t, val) reinterpret_cast<t>(val)
#else
#define WINPR_EVENT_CAST(t, val) (t)(val)
#endif
 
#define MAX_EVENT_HANDLERS 32
 
  typedef struct
  {
    const char* EventName;
    wEventArgs EventArgs;
    size_t EventHandlerCount;
    pEventHandler EventHandlers[MAX_EVENT_HANDLERS];
  } wEventType;
 
#define EventArgsInit(_event_args, _sender)       \
  memset(_event_args, 0, sizeof(*_event_args)); \
  (_event_args)->e.Size = sizeof(*_event_args); \
  (_event_args)->e.Sender = _sender
 
#define DEFINE_EVENT_HANDLER(name) \
  typedef void (*p##name##EventHandler)(void* context, const name##EventArgs* e)
 
#define DEFINE_EVENT_RAISE(name)                                                                \
  static INLINE int PubSub_On##name(wPubSub* pubSub, void* context, const name##EventArgs* e) \
  {                                                                                           \
    WINPR_ASSERT(e);                                                                        \
    return PubSub_OnEvent(pubSub, #name, context, &e->e);                                   \
  }
 
#define DEFINE_EVENT_SUBSCRIBE(name)                                                              \
  static INLINE int PubSub_Subscribe##name(wPubSub* pubSub, p##name##EventHandler EventHandler) \
  {                                                                                             \
    return PubSub_Subscribe(pubSub, #name, EventHandler);                                     \
  }
 
#define DEFINE_EVENT_UNSUBSCRIBE(name)                                             \
  static INLINE int PubSub_Unsubscribe##name(wPubSub* pubSub,                    \
                                             p##name##EventHandler EventHandler) \
  {                                                                              \
    return PubSub_Unsubscribe(pubSub, #name, EventHandler);                    \
  }
 
#define DEFINE_EVENT_BEGIN(name) \
  typedef struct               \
  {                            \
    wEventArgs e;
 
#define DEFINE_EVENT_END(name)   \
  }                            \
  name##EventArgs;             \
  DEFINE_EVENT_HANDLER(name);  \
  DEFINE_EVENT_RAISE(name)     \
  DEFINE_EVENT_SUBSCRIBE(name) \
  DEFINE_EVENT_UNSUBSCRIBE(name)
 
#define DEFINE_EVENT_ENTRY(name)                     \
  {                                                \
#name, { sizeof(name##EventArgs), NULL }, 0, \
    {                                            \
      NULL                                     \
    }                                            \
  }
 
  typedef struct s_wPubSub wPubSub;
 
  WINPR_API void PubSub_Lock(wPubSub* pubSub);
  WINPR_API void PubSub_Unlock(wPubSub* pubSub);
 
  WINPR_API wEventType* PubSub_GetEventTypes(wPubSub* pubSub, size_t* count);
  WINPR_API void PubSub_AddEventTypes(wPubSub* pubSub, wEventType* events, size_t count);
  WINPR_API wEventType* PubSub_FindEventType(wPubSub* pubSub, const char* EventName);
 
  WINPR_API int PubSub_Subscribe(wPubSub* pubSub, const char* EventName, ...);
  WINPR_API int PubSub_Unsubscribe(wPubSub* pubSub, const char* EventName, ...);
 
  WINPR_API int PubSub_OnEvent(wPubSub* pubSub, const char* EventName, void* context,
                               const wEventArgs* e);
 
  WINPR_API void PubSub_Free(wPubSub* pubSub);
 
  WINPR_ATTR_MALLOC(PubSub_Free, 1)
  WINPR_API wPubSub* PubSub_New(BOOL synchronized);
 
#ifdef __cplusplus
}
#endif
 
#endif /* WINPR_COLLECTIONS_H */