FreeRDP/winpr/libwinpr/utils/collections/PubSub.c
2022-03-03 11:26:48 +01:00

256 lines
5.0 KiB
C

/**
* WinPR: Windows Portable Runtime
* Publisher/Subscriber Pattern
*
* 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.
*/
#include <winpr/config.h>
#include <winpr/crt.h>
#include <winpr/collections.h>
/**
* Events (C# Programming Guide)
* http://msdn.microsoft.com/en-us/library/awbftdfh.aspx
*/
struct s_wPubSub
{
CRITICAL_SECTION lock;
BOOL synchronized;
size_t size;
size_t count;
wEventType* events;
};
/**
* Properties
*/
wEventType* PubSub_GetEventTypes(wPubSub* pubSub, size_t* count)
{
WINPR_ASSERT(pubSub);
if (count)
*count = pubSub->count;
return pubSub->events;
}
/**
* Methods
*/
void PubSub_Lock(wPubSub* pubSub)
{
WINPR_ASSERT(pubSub);
if (pubSub->synchronized)
EnterCriticalSection(&pubSub->lock);
}
void PubSub_Unlock(wPubSub* pubSub)
{
WINPR_ASSERT(pubSub);
if (pubSub->synchronized)
LeaveCriticalSection(&pubSub->lock);
}
wEventType* PubSub_FindEventType(wPubSub* pubSub, const char* EventName)
{
size_t index;
wEventType* event = NULL;
WINPR_ASSERT(pubSub);
WINPR_ASSERT(EventName);
for (index = 0; index < pubSub->count; index++)
{
if (strcmp(pubSub->events[index].EventName, EventName) == 0)
{
event = &(pubSub->events[index]);
break;
}
}
return event;
}
void PubSub_AddEventTypes(wPubSub* pubSub, wEventType* events, size_t count)
{
WINPR_ASSERT(pubSub);
WINPR_ASSERT(events || (count == 0));
if (pubSub->synchronized)
PubSub_Lock(pubSub);
while (pubSub->count + count >= pubSub->size)
{
size_t new_size;
wEventType* new_event;
new_size = pubSub->size * 2;
new_event = (wEventType*)realloc(pubSub->events, new_size * sizeof(wEventType));
if (!new_event)
return;
pubSub->size = new_size;
pubSub->events = new_event;
}
CopyMemory(&pubSub->events[pubSub->count], events, count * sizeof(wEventType));
pubSub->count += count;
if (pubSub->synchronized)
PubSub_Unlock(pubSub);
}
int PubSub_Subscribe(wPubSub* pubSub, const char* EventName, pEventHandler EventHandler)
{
wEventType* event;
int status = -1;
WINPR_ASSERT(pubSub);
WINPR_ASSERT(EventHandler);
if (pubSub->synchronized)
PubSub_Lock(pubSub);
event = PubSub_FindEventType(pubSub, EventName);
if (event)
{
status = 0;
if (event->EventHandlerCount < MAX_EVENT_HANDLERS)
event->EventHandlers[event->EventHandlerCount++] = EventHandler;
else
status = -1;
}
if (pubSub->synchronized)
PubSub_Unlock(pubSub);
return status;
}
int PubSub_Unsubscribe(wPubSub* pubSub, const char* EventName, pEventHandler EventHandler)
{
size_t index;
wEventType* event;
int status = -1;
WINPR_ASSERT(pubSub);
WINPR_ASSERT(EventName);
WINPR_ASSERT(EventHandler);
if (pubSub->synchronized)
PubSub_Lock(pubSub);
event = PubSub_FindEventType(pubSub, EventName);
if (event)
{
status = 0;
for (index = 0; index < event->EventHandlerCount; index++)
{
if (event->EventHandlers[index] == EventHandler)
{
event->EventHandlers[index] = NULL;
event->EventHandlerCount--;
MoveMemory(&event->EventHandlers[index], &event->EventHandlers[index + 1],
(MAX_EVENT_HANDLERS - index - 1) * sizeof(pEventHandler));
status = 1;
}
}
}
if (pubSub->synchronized)
PubSub_Unlock(pubSub);
return status;
}
int PubSub_OnEvent(wPubSub* pubSub, const char* EventName, void* context, const wEventArgs* e)
{
size_t index;
wEventType* event;
int status = -1;
WINPR_ASSERT(pubSub);
WINPR_ASSERT(e);
if (pubSub->synchronized)
PubSub_Lock(pubSub);
event = PubSub_FindEventType(pubSub, EventName);
if (pubSub->synchronized)
PubSub_Unlock(pubSub);
if (event)
{
status = 0;
for (index = 0; index < event->EventHandlerCount; index++)
{
if (event->EventHandlers[index])
{
event->EventHandlers[index](context, e);
status++;
}
}
}
return status;
}
/**
* Construction, Destruction
*/
wPubSub* PubSub_New(BOOL synchronized)
{
wPubSub* pubSub = (wPubSub*)calloc(1, sizeof(wPubSub));
if (!pubSub)
return NULL;
pubSub->synchronized = synchronized;
if (pubSub->synchronized && !InitializeCriticalSectionAndSpinCount(&pubSub->lock, 4000))
goto fail;
pubSub->count = 0;
pubSub->size = 64;
pubSub->events = (wEventType*)calloc(pubSub->size, sizeof(wEventType));
if (!pubSub->events)
goto fail;
return pubSub;
fail:
PubSub_Free(pubSub);
return NULL;
}
void PubSub_Free(wPubSub* pubSub)
{
if (pubSub)
{
if (pubSub->synchronized)
DeleteCriticalSection(&pubSub->lock);
free(pubSub->events);
free(pubSub);
}
}