FreeRDP
Loading...
Searching...
No Matches
collections.h
1
20#ifndef WINPR_COLLECTIONS_H
21#define WINPR_COLLECTIONS_H
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <stdarg.h>
27
28#include <winpr/winpr.h>
29#include <winpr/wtypes.h>
30#include <winpr/assert.h>
31
32#include <winpr/crt.h>
33#include <winpr/synch.h>
34#include <winpr/stream.h>
35
36#ifdef __cplusplus
37extern "C"
38{
39#endif
40
41 typedef void* (*OBJECT_NEW_FN)(const void* val);
42 typedef void (*OBJECT_INIT_FN)(void* obj);
43 typedef void (*OBJECT_UNINIT_FN)(void* obj);
44 typedef void (*OBJECT_FREE_FN)(void* obj);
45 typedef BOOL (*OBJECT_EQUALS_FN)(const void* objA, const void* objB);
46
51 typedef struct
52 {
53 WINPR_ATTR_NODISCARD OBJECT_NEW_FN
54 fnObjectNew;
55 OBJECT_INIT_FN
56 fnObjectInit;
57 OBJECT_UNINIT_FN
58 fnObjectUninit;
59 OBJECT_FREE_FN fnObjectFree;
60 WINPR_ATTR_NODISCARD OBJECT_EQUALS_FN
61 fnObjectEquals;
62 } wObject;
63
64 /* utility function with compatible arguments for string data */
65
71 WINPR_ATTR_NODISCARD
72 WINPR_API void* winpr_ObjectStringClone(const void* pvstr);
73
79 WINPR_ATTR_NODISCARD
80 WINPR_API void* winpr_ObjectWStringClone(const void* pvstr);
81
86 WINPR_API void winpr_ObjectStringFree(void* pvstr);
87
88 /* System.Collections.Queue */
89
90 typedef struct s_wQueue wQueue;
91
98 WINPR_ATTR_NODISCARD
99 WINPR_API size_t Queue_Count(wQueue* queue);
100
107 WINPR_ATTR_NODISCARD
108 WINPR_API size_t Queue_Capacity(wQueue* queue);
109
114 WINPR_API void Queue_Lock(wQueue* queue);
115
120 WINPR_API void Queue_Unlock(wQueue* queue);
121
127 WINPR_ATTR_NODISCARD
128 WINPR_API HANDLE Queue_Event(wQueue* queue);
129
137 WINPR_ATTR_NODISCARD
138 WINPR_API wObject* Queue_Object(wQueue* queue);
139
144 WINPR_API void Queue_Clear(wQueue* queue);
145
153 WINPR_ATTR_NODISCARD
154 WINPR_API BOOL Queue_Contains(wQueue* queue, const void* obj);
155
165 WINPR_ATTR_NODISCARD
166 WINPR_API BOOL Queue_Enqueue(wQueue* queue, const void* obj);
167
175 WINPR_ATTR_NODISCARD
176 WINPR_API void* Queue_Dequeue(wQueue* queue);
177
185 WINPR_ATTR_NODISCARD
186 WINPR_API void* Queue_Peek(wQueue* queue);
187
195 WINPR_API void Queue_Discard(wQueue* queue);
196
201 WINPR_API void Queue_Free(wQueue* queue);
202
215 WINPR_ATTR_MALLOC(Queue_Free, 1)
216 WINPR_API wQueue* Queue_New(BOOL synchronized, SSIZE_T capacity, SSIZE_T growthFactor);
217
218 /* System.Collections.Stack */
219
220 typedef struct s_wStack wStack;
221
222 WINPR_ATTR_NODISCARD
223 WINPR_API size_t Stack_Count(wStack* stack);
224
225 WINPR_ATTR_NODISCARD
226 WINPR_API BOOL Stack_IsSynchronized(wStack* stack);
227
228 WINPR_ATTR_NODISCARD
229 WINPR_API wObject* Stack_Object(wStack* stack);
230
231 WINPR_API void Stack_Clear(wStack* stack);
232
233 WINPR_ATTR_NODISCARD
234 WINPR_API BOOL Stack_Contains(wStack* stack, const void* obj);
235
236 WINPR_API void Stack_Push(wStack* stack, void* obj);
237
238 WINPR_ATTR_NODISCARD
239 WINPR_API void* Stack_Pop(wStack* stack);
240
241 WINPR_ATTR_NODISCARD
242 WINPR_API void* Stack_Peek(wStack* stack);
243
244 WINPR_API void Stack_Free(wStack* stack);
245
246 WINPR_ATTR_MALLOC(Stack_Free, 1)
247 WINPR_API wStack* Stack_New(BOOL synchronized);
248
249 /* System.Collections.ArrayList */
250
251 typedef struct s_wArrayList wArrayList;
252
253 WINPR_ATTR_NODISCARD
254 WINPR_API size_t ArrayList_Capacity(wArrayList* arrayList);
255
256 WINPR_ATTR_NODISCARD
257 WINPR_API size_t ArrayList_Count(wArrayList* arrayList);
258
259 WINPR_ATTR_NODISCARD
260 WINPR_API size_t ArrayList_Items(wArrayList* arrayList, ULONG_PTR** ppItems);
261
262 WINPR_ATTR_NODISCARD
263 WINPR_API BOOL ArrayList_IsFixedSized(wArrayList* arrayList);
264
265 WINPR_ATTR_NODISCARD
266 WINPR_API BOOL ArrayList_IsReadOnly(wArrayList* arrayList);
267
268 WINPR_ATTR_NODISCARD
269 WINPR_API BOOL ArrayList_IsSynchronized(wArrayList* arrayList);
270
271 WINPR_API void ArrayList_Lock(wArrayList* arrayList);
272 WINPR_API void ArrayList_Unlock(wArrayList* arrayList);
273
274 WINPR_ATTR_NODISCARD
275 WINPR_API void* ArrayList_GetItem(wArrayList* arrayList, size_t index);
276
277 WINPR_ATTR_NODISCARD
278 WINPR_API BOOL ArrayList_SetItem(wArrayList* arrayList, size_t index, const void* obj);
279
280 WINPR_ATTR_NODISCARD
281 WINPR_API wObject* ArrayList_Object(wArrayList* arrayList);
282
283 typedef BOOL (*ArrayList_ForEachFkt)(void* data, size_t index, va_list ap);
284
285 WINPR_ATTR_NODISCARD
286 WINPR_API BOOL ArrayList_ForEach(wArrayList* arrayList, ArrayList_ForEachFkt fkt, ...);
287
288 WINPR_ATTR_NODISCARD
289 WINPR_API BOOL ArrayList_ForEachAP(wArrayList* arrayList, ArrayList_ForEachFkt fkt, va_list ap);
290
291 WINPR_API void ArrayList_Clear(wArrayList* arrayList);
292
293 WINPR_ATTR_NODISCARD
294 WINPR_API BOOL ArrayList_Contains(wArrayList* arrayList, const void* obj);
295
296#if defined(WITH_WINPR_DEPRECATED)
297 WINPR_DEPRECATED(WINPR_ATTR_NODISCARD WINPR_API int ArrayList_Add(wArrayList* arrayList,
298 const void* obj));
299#endif
300
301 WINPR_API BOOL ArrayList_Append(wArrayList* arrayList, const void* obj);
302
303 WINPR_ATTR_NODISCARD
304 WINPR_API BOOL ArrayList_Insert(wArrayList* arrayList, size_t index, const void* obj);
305
306 WINPR_API BOOL ArrayList_Remove(wArrayList* arrayList, const void* obj);
307
308 WINPR_API BOOL ArrayList_RemoveAt(wArrayList* arrayList, size_t index);
309
310 WINPR_ATTR_NODISCARD
311 WINPR_API SSIZE_T ArrayList_IndexOf(wArrayList* arrayList, const void* obj, SSIZE_T startIndex,
312 SSIZE_T count);
313
314 WINPR_ATTR_NODISCARD
315 WINPR_API SSIZE_T ArrayList_LastIndexOf(wArrayList* arrayList, const void* obj,
316 SSIZE_T startIndex, SSIZE_T count);
317
318 WINPR_API void ArrayList_Free(wArrayList* arrayList);
319
320 WINPR_ATTR_MALLOC(ArrayList_Free, 1)
321 WINPR_API wArrayList* ArrayList_New(BOOL synchronized);
322
323 /* System.Collections.DictionaryBase */
324
325 /* System.Collections.Specialized.ListDictionary */
326 typedef struct s_wListDictionary wListDictionary;
327
334 WINPR_ATTR_NODISCARD
335 WINPR_API wObject* ListDictionary_KeyObject(wListDictionary* listDictionary);
336
343 WINPR_ATTR_NODISCARD
344 WINPR_API wObject* ListDictionary_ValueObject(wListDictionary* listDictionary);
345
352 WINPR_ATTR_NODISCARD
353 WINPR_API size_t ListDictionary_Count(wListDictionary* listDictionary);
354
359 WINPR_API void ListDictionary_Lock(wListDictionary* listDictionary);
364 WINPR_API void ListDictionary_Unlock(wListDictionary* listDictionary);
365
375 WINPR_ATTR_NODISCARD
376 WINPR_API BOOL ListDictionary_Add(wListDictionary* listDictionary, const void* key,
377 const void* value);
378
386 WINPR_ATTR_NODISCARD
387 WINPR_API void* ListDictionary_Take(wListDictionary* listDictionary, const void* key);
388
394 WINPR_API void ListDictionary_Remove(wListDictionary* listDictionary, const void* key);
395
403 WINPR_ATTR_NODISCARD
404 WINPR_API void* ListDictionary_Take_Head(wListDictionary* listDictionary);
405
410 WINPR_API void ListDictionary_Remove_Head(wListDictionary* listDictionary);
411
416 WINPR_API void ListDictionary_Clear(wListDictionary* listDictionary);
417
425 WINPR_ATTR_NODISCARD
426 WINPR_API BOOL ListDictionary_Contains(wListDictionary* listDictionary, const void* key);
427
436 WINPR_ATTR_NODISCARD
437 WINPR_API size_t ListDictionary_GetKeys(wListDictionary* listDictionary, ULONG_PTR** ppKeys);
438
447 WINPR_ATTR_NODISCARD
448 WINPR_API void* ListDictionary_GetItemValue(wListDictionary* listDictionary, const void* key);
449
459 WINPR_ATTR_NODISCARD
460 WINPR_API BOOL ListDictionary_SetItemValue(wListDictionary* listDictionary, const void* key,
461 const void* value);
462
467 WINPR_API void ListDictionary_Free(wListDictionary* listDictionary);
468
475 WINPR_ATTR_MALLOC(ListDictionary_Free, 1)
476 WINPR_API wListDictionary* ListDictionary_New(BOOL synchronized);
477
478 /* System.Collections.Generic.LinkedList<T> */
479
480 typedef struct s_wLinkedList wLinkedList;
481
488 WINPR_ATTR_NODISCARD
489 WINPR_API size_t LinkedList_Count(wLinkedList* list);
490
497 WINPR_ATTR_NODISCARD
498 WINPR_API void* LinkedList_First(wLinkedList* list);
499
506 WINPR_ATTR_NODISCARD
507 WINPR_API void* LinkedList_Last(wLinkedList* list);
508
516 WINPR_ATTR_NODISCARD
517 WINPR_API BOOL LinkedList_Contains(wLinkedList* list, const void* value);
518
525 WINPR_API void LinkedList_Clear(wLinkedList* list);
526
535 WINPR_ATTR_NODISCARD
536 WINPR_API BOOL LinkedList_AddFirst(wLinkedList* list, const void* value);
537
546 WINPR_ATTR_NODISCARD
547 WINPR_API BOOL LinkedList_AddLast(wLinkedList* list, const void* value);
548
557 WINPR_API BOOL LinkedList_Remove(wLinkedList* list, const void* value);
558
565 WINPR_API void LinkedList_RemoveFirst(wLinkedList* list);
566
573 WINPR_API void LinkedList_RemoveLast(wLinkedList* list);
574
580 WINPR_API void LinkedList_Enumerator_Reset(wLinkedList* list);
581
588 WINPR_ATTR_NODISCARD
589 WINPR_API void* LinkedList_Enumerator_Current(wLinkedList* list);
590
597 WINPR_ATTR_NODISCARD
598 WINPR_API BOOL LinkedList_Enumerator_MoveNext(wLinkedList* list);
599
604 WINPR_API void LinkedList_Free(wLinkedList* list);
605
610 WINPR_ATTR_MALLOC(LinkedList_Free, 1)
611 WINPR_API wLinkedList* LinkedList_New(void);
612
619 WINPR_ATTR_NODISCARD
620 WINPR_API wObject* LinkedList_Object(wLinkedList* list);
621
622 /* System.Collections.Generic.KeyValuePair<TKey,TValue> */
623
624 /* Countdown Event */
625
626 typedef struct CountdownEvent wCountdownEvent;
627
634 WINPR_ATTR_NODISCARD
635 WINPR_API size_t CountdownEvent_CurrentCount(wCountdownEvent* countdown);
636
643 WINPR_ATTR_NODISCARD
644 WINPR_API size_t CountdownEvent_InitialCount(wCountdownEvent* countdown);
645
652 WINPR_ATTR_NODISCARD
653 WINPR_API BOOL CountdownEvent_IsSet(wCountdownEvent* countdown);
654
662 WINPR_ATTR_NODISCARD
663 WINPR_API HANDLE CountdownEvent_WaitHandle(wCountdownEvent* countdown);
664
671 WINPR_API void CountdownEvent_AddCount(wCountdownEvent* countdown, size_t signalCount);
672
680 WINPR_API BOOL CountdownEvent_Signal(wCountdownEvent* countdown, size_t signalCount);
681
687 WINPR_API void CountdownEvent_Reset(wCountdownEvent* countdown, size_t count);
688
693 WINPR_API void CountdownEvent_Free(wCountdownEvent* countdown);
694
701 WINPR_ATTR_MALLOC(CountdownEvent_Free, 1)
702 WINPR_API wCountdownEvent* CountdownEvent_New(size_t initialCount);
703
704 /* Hash Table */
705
706 typedef UINT32 (*HASH_TABLE_HASH_FN)(const void* key);
707
708 typedef struct s_wHashTable wHashTable;
709
710 typedef BOOL (*HASH_TABLE_FOREACH_FN)(const void* key, void* value, void* arg);
711
712 WINPR_ATTR_NODISCARD
713 WINPR_API size_t HashTable_Count(wHashTable* table);
714
715#if defined(WITH_WINPR_DEPRECATED)
716 WINPR_DEPRECATED(WINPR_ATTR_NODISCARD WINPR_API int HashTable_Add(wHashTable* table,
717 const void* key,
718 const void* value));
719#endif
720
721 WINPR_ATTR_NODISCARD
722 WINPR_API BOOL HashTable_Insert(wHashTable* table, const void* key, const void* value);
723
724 WINPR_API BOOL HashTable_Remove(wHashTable* table, const void* key);
725
726 WINPR_API void HashTable_Clear(wHashTable* table);
727
728 WINPR_ATTR_NODISCARD
729 WINPR_API BOOL HashTable_Contains(wHashTable* table, const void* key);
730
731 WINPR_ATTR_NODISCARD
732 WINPR_API BOOL HashTable_ContainsKey(wHashTable* table, const void* key);
733
734 WINPR_ATTR_NODISCARD
735 WINPR_API BOOL HashTable_ContainsValue(wHashTable* table, const void* value);
736
737 WINPR_ATTR_NODISCARD
738 WINPR_API void* HashTable_GetItemValue(wHashTable* table, const void* key);
739
740 WINPR_ATTR_NODISCARD
741 WINPR_API BOOL HashTable_SetItemValue(wHashTable* table, const void* key, const void* value);
742
743 WINPR_ATTR_NODISCARD
744 WINPR_API size_t HashTable_GetKeys(wHashTable* table, ULONG_PTR** ppKeys);
745
746 WINPR_ATTR_NODISCARD
747 WINPR_API BOOL HashTable_Foreach(wHashTable* table, HASH_TABLE_FOREACH_FN fn, VOID* arg);
748
749 WINPR_ATTR_NODISCARD
750 WINPR_API UINT32 HashTable_PointerHash(const void* pointer);
751
752 WINPR_ATTR_NODISCARD
753 WINPR_API BOOL HashTable_PointerCompare(const void* pointer1, const void* pointer2);
754
755 WINPR_ATTR_NODISCARD
756 WINPR_API UINT32 HashTable_StringHash(const void* key);
757
758 WINPR_ATTR_NODISCARD
759 WINPR_API BOOL HashTable_StringCompare(const void* string1, const void* string2);
760
761 WINPR_ATTR_NODISCARD
762 WINPR_API void* HashTable_StringClone(const void* str);
763
764 WINPR_API void HashTable_StringFree(void* str);
765
766 WINPR_API void HashTable_Free(wHashTable* table);
767
768 WINPR_ATTR_MALLOC(HashTable_Free, 1)
769 WINPR_API wHashTable* HashTable_New(BOOL synchronized);
770
771 WINPR_API void HashTable_Lock(wHashTable* table);
772 WINPR_API void HashTable_Unlock(wHashTable* table);
773
774 WINPR_ATTR_NODISCARD
775 WINPR_API wObject* HashTable_KeyObject(wHashTable* table);
776
777 WINPR_ATTR_NODISCARD
778 WINPR_API wObject* HashTable_ValueObject(wHashTable* table);
779
780 WINPR_ATTR_NODISCARD
781 WINPR_API BOOL HashTable_SetHashFunction(wHashTable* table, HASH_TABLE_HASH_FN fn);
782
783 /* Utility function to setup hash table for strings */
784 WINPR_ATTR_NODISCARD
785 WINPR_API BOOL HashTable_SetupForStringData(wHashTable* table, BOOL stringValues);
786
787 /* BufferPool */
788
789 typedef struct s_wBufferPool wBufferPool;
790
791 WINPR_ATTR_NODISCARD
792 WINPR_API SSIZE_T BufferPool_GetPoolSize(wBufferPool* pool);
793
794 WINPR_ATTR_NODISCARD
795 WINPR_API SSIZE_T BufferPool_GetBufferSize(wBufferPool* pool, const void* buffer);
796
797 WINPR_ATTR_NODISCARD
798 WINPR_API void* BufferPool_Take(wBufferPool* pool, SSIZE_T bufferSize);
799
800 WINPR_API BOOL BufferPool_Return(wBufferPool* pool, void* buffer);
801
802 WINPR_API void BufferPool_Clear(wBufferPool* pool);
803
804 WINPR_API void BufferPool_Free(wBufferPool* pool);
805
806 WINPR_ATTR_MALLOC(BufferPool_Free, 1)
807 WINPR_API wBufferPool* BufferPool_New(BOOL synchronized, SSIZE_T fixedSize, DWORD alignment);
808
809 /* ObjectPool */
810
811 typedef struct s_wObjectPool wObjectPool;
812
813 WINPR_ATTR_NODISCARD
814
815 WINPR_API void* ObjectPool_Take(wObjectPool* pool);
816 WINPR_API void ObjectPool_Return(wObjectPool* pool, void* obj);
817 WINPR_API void ObjectPool_Clear(wObjectPool* pool);
818
819 WINPR_ATTR_NODISCARD
820 WINPR_API wObject* ObjectPool_Object(wObjectPool* pool);
821
822 WINPR_API void ObjectPool_Free(wObjectPool* pool);
823
824 WINPR_ATTR_MALLOC(ObjectPool_Free, 1)
825 WINPR_API wObjectPool* ObjectPool_New(BOOL synchronized);
826
827 /* Message Queue */
828
829 typedef struct s_wMessage wMessage;
830
831 typedef void (*MESSAGE_FREE_FN)(wMessage* message);
832
833 struct s_wMessage
834 {
835 UINT32 id;
836 void* context;
837 void* wParam;
838 void* lParam;
839 UINT64 time;
840 MESSAGE_FREE_FN Free;
841 };
842
843 typedef struct s_wMessageQueue wMessageQueue;
844
845#define WMQ_QUIT 0xFFFFFFFF
846
847 WINPR_ATTR_NODISCARD
848 WINPR_API wObject* MessageQueue_Object(wMessageQueue* queue);
849
850 WINPR_ATTR_NODISCARD
851 WINPR_API HANDLE MessageQueue_Event(wMessageQueue* queue);
852
853 WINPR_ATTR_NODISCARD
854 WINPR_API BOOL MessageQueue_Wait(wMessageQueue* queue);
855
862 WINPR_ATTR_NODISCARD
863 WINPR_API size_t MessageQueue_Size(wMessageQueue* queue);
864
871 WINPR_ATTR_NODISCARD
872 WINPR_API size_t MessageQueue_Capacity(wMessageQueue* queue);
873
874 WINPR_ATTR_NODISCARD
875 WINPR_API BOOL MessageQueue_Dispatch(wMessageQueue* queue, const wMessage* message);
876
877 WINPR_ATTR_NODISCARD
878 WINPR_API BOOL MessageQueue_Post(wMessageQueue* queue, void* context, UINT32 type, void* wParam,
879 void* lParam);
880
881 WINPR_API BOOL MessageQueue_PostQuit(wMessageQueue* queue, int nExitCode);
882
883 WINPR_ATTR_NODISCARD
884 WINPR_API int MessageQueue_Get(wMessageQueue* queue, wMessage* message);
885
886 WINPR_ATTR_NODISCARD
887 WINPR_API int MessageQueue_Peek(wMessageQueue* queue, wMessage* message, BOOL remove);
888
899 WINPR_API int MessageQueue_Clear(wMessageQueue* queue);
900
912 WINPR_API void MessageQueue_Free(wMessageQueue* queue);
913
926 WINPR_ATTR_MALLOC(MessageQueue_Free, 1)
927 WINPR_API wMessageQueue* MessageQueue_New(const wObject* callback);
928
929 /* Message Pipe */
930
931 typedef struct
932 {
933 wMessageQueue* In;
934 wMessageQueue* Out;
935 } wMessagePipe;
936
937 WINPR_API void MessagePipe_PostQuit(wMessagePipe* pipe, int nExitCode);
938
939 WINPR_API void MessagePipe_Free(wMessagePipe* pipe);
940
941 WINPR_ATTR_MALLOC(MessagePipe_Free, 1)
942 WINPR_API wMessagePipe* MessagePipe_New(void);
943
944 /* Publisher/Subscriber Pattern */
945
946 typedef struct
947 {
948 DWORD Size;
949 const char* Sender;
950 } wEventArgs;
951
952 typedef void (*pEventHandler)(void* context, const wEventArgs* e);
953
954#ifdef __cplusplus
955#define WINPR_EVENT_CAST(t, val) reinterpret_cast<t>(val)
956#else
957#define WINPR_EVENT_CAST(t, val) (t)(val)
958#endif
959
960#define MAX_EVENT_HANDLERS 32
961
962 typedef struct
963 {
964 const char* EventName;
965 wEventArgs EventArgs;
966 size_t EventHandlerCount;
967 pEventHandler EventHandlers[MAX_EVENT_HANDLERS];
968 } wEventType;
969
970#define EventArgsInit(_event_args, _sender) \
971 memset(_event_args, 0, sizeof(*_event_args)); \
972 (_event_args)->e.Size = sizeof(*_event_args); \
973 (_event_args)->e.Sender = _sender
974
975#define DEFINE_EVENT_HANDLER(name) \
976 typedef void (*p##name##EventHandler)(void* context, const name##EventArgs* e)
977
978#define DEFINE_EVENT_RAISE(name) \
979 WINPR_ATTR_NODISCARD static inline int PubSub_On##name(wPubSub* pubSub, void* context, \
980 const name##EventArgs* e) \
981 { \
982 WINPR_ASSERT(e); \
983 return PubSub_OnEvent(pubSub, #name, context, &e->e); \
984 }
985
986#define DEFINE_EVENT_SUBSCRIBE(name) \
987 WINPR_ATTR_NODISCARD static inline int PubSub_Subscribe##name( \
988 wPubSub* pubSub, p##name##EventHandler EventHandler) \
989 { \
990 return PubSub_Subscribe(pubSub, #name, EventHandler); \
991 }
992
993#define DEFINE_EVENT_UNSUBSCRIBE(name) \
994 static inline int PubSub_Unsubscribe##name(wPubSub* pubSub, \
995 p##name##EventHandler EventHandler) \
996 { \
997 return PubSub_Unsubscribe(pubSub, #name, EventHandler); \
998 }
999
1000#define DEFINE_EVENT_BEGIN(name) \
1001 typedef struct \
1002 { \
1003 wEventArgs e;
1004
1005#define DEFINE_EVENT_END(name) \
1006 } \
1007 name##EventArgs; \
1008 DEFINE_EVENT_HANDLER(name); \
1009 DEFINE_EVENT_RAISE(name) \
1010 DEFINE_EVENT_SUBSCRIBE(name) \
1011 DEFINE_EVENT_UNSUBSCRIBE(name)
1012
1013#define DEFINE_EVENT_ENTRY(name) \
1014 { \
1015 #name, { sizeof(name##EventArgs), nullptr }, 0, \
1016 { \
1017 nullptr \
1018 } \
1019 }
1020
1021 typedef struct s_wPubSub wPubSub;
1022
1023 WINPR_API void PubSub_Lock(wPubSub* pubSub);
1024 WINPR_API void PubSub_Unlock(wPubSub* pubSub);
1025
1026 WINPR_ATTR_NODISCARD
1027 WINPR_API wEventType* PubSub_GetEventTypes(wPubSub* pubSub, size_t* count);
1028
1029 WINPR_API void PubSub_AddEventTypes(wPubSub* pubSub, wEventType* events, size_t count);
1030
1031 WINPR_ATTR_NODISCARD
1032 WINPR_API wEventType* PubSub_FindEventType(wPubSub* pubSub, const char* EventName);
1033
1034 WINPR_ATTR_NODISCARD
1035 WINPR_API int PubSub_Subscribe(wPubSub* pubSub, const char* EventName, ...);
1036
1037 WINPR_API int PubSub_Unsubscribe(wPubSub* pubSub, const char* EventName, ...);
1038
1039 WINPR_ATTR_NODISCARD
1040 WINPR_API int PubSub_OnEvent(wPubSub* pubSub, const char* EventName, void* context,
1041 const wEventArgs* e);
1042
1043 WINPR_API void PubSub_Free(wPubSub* pubSub);
1044
1045 WINPR_ATTR_MALLOC(PubSub_Free, 1)
1046 WINPR_API wPubSub* PubSub_New(BOOL synchronized);
1047
1048#ifdef __cplusplus
1049}
1050#endif
1051
1052#endif /* WINPR_COLLECTIONS_H */
s_wMessage
Definition collections.h:834
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectUninit
OBJECT_UNINIT_FN fnObjectUninit
Definition collections.h:58
wObject::fnObjectEquals
WINPR_ATTR_NODISCARD OBJECT_EQUALS_FN fnObjectEquals
Definition collections.h:61
wObject::fnObjectNew
WINPR_ATTR_NODISCARD OBJECT_NEW_FN fnObjectNew
Definition collections.h:54
wObject::fnObjectInit
OBJECT_INIT_FN fnObjectInit
Definition collections.h:56