xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

SP3-108 

Removed singleton instance from event manager and changed it to static class instead.

WARNING: Might need to change back to singleton next time, I had to do it previously for some reason but I don't remember why
This commit is contained in:
Xiao Qi 2022-09-15 12:06:09 +08:00
parent d62201367a
commit ddf6a7bee5
5 changed files with 35 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
SHADE_Engine/SHADE_Engine.vcxproj.filters
View File

@ -171,6 +171,9 @@
<ClInclude Include="src\Events\SHEvent.h"> <ClInclude Include="src\Events\SHEvent.h">
<Filter>Events</Filter> <Filter>Events</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Events\SHEventDefines.h">
<Filter>Events</Filter>
</ClInclude>
<ClInclude Include="src\Events\SHEventManager.h"> <ClInclude Include="src\Events\SHEventManager.h">
<Filter>Events</Filter> <Filter>Events</Filter>
</ClInclude> </ClInclude>
@ -405,7 +408,6 @@
<ClInclude Include="src\Tools\SHUtilities.h"> <ClInclude Include="src\Tools\SHUtilities.h">
<Filter>Tools</Filter> <Filter>Tools</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\Events\SHEventDefines.h" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="src\ECS_Base\Components\SHComponent.cpp"> <ClCompile Include="src\ECS_Base\Components\SHComponent.cpp">

2
SHADE_Engine/src/Events/SHEvent.h
View File

@ -16,7 +16,7 @@ namespace SHADE
struct SHEvent struct SHEvent
{ {
SHEventIdentifier type; SHEventIdentifier type;
SHEventDataPtr data; SHEventDataPtr dataPtr;
SHEventHandle handle; SHEventHandle handle;
}; };
} }

47
SHADE_Engine/src/Events/SHEventManager.cpp
View File

@ -12,47 +12,18 @@
namespace SHADE namespace SHADE
{ {
SHEventManager* SHEventManager::instance; std::unordered_map<SHEventIdentifier, ResponseVec> SHEventManager::packageReceiverRegistry;
std::unordered_map<SHEventHandle, SHEventDataPtr> SHEventManager::dataEventMap;
/**************************************************************************** SHEventHandle SHEventManager::handleCounter{ 0 };
* \brief Ctor and Dtor. Dtor will delete instance of self stored at
* data member instance.
****************************************************************************/
SHEventManager::SHEventManager()
{
}
/****************************************************************************
* \brief Exit function to terminate the manager properly and deallocate
* memory.
****************************************************************************/
void SHEventManager::Exit()
{
delete instance;
}
/****************************************************************************
* \brief Returns singleton instance of event manager in heap memory. If
* instance does not exist, one is created immediately.
****************************************************************************/
SHEventManager& SHEventManager::GetEventManagerInstance()
{
// Create instance of event manager and return
if (!instance)
{
instance = new SHEventManager();
}
return *instance;
}
/**************************************************************************** /****************************************************************************
* \brief Returns function pointer to entry point for events. * \brief Returns function pointer to entry point for events.
****************************************************************************/ ****************************************************************************/
EventManagerListener SHEventManager::GetListenerFunction() EventManagerListener SHEventManager::GetListenerFunction()
{ {
return &(instance->CatchEvent); return &CatchEvent;
} }
/**************************************************************************** /****************************************************************************
@ -66,7 +37,7 @@ namespace SHADE
// Do something with the event // Do something with the event
instance->Broadcast(event); Broadcast(event);
} }
/**************************************************************************** /****************************************************************************
@ -80,11 +51,11 @@ namespace SHADE
****************************************************************************/ ****************************************************************************/
void SHEventManager::SubscribeTo(SHEventIdentifier pkgType, ReceiverPtr receiver) void SHEventManager::SubscribeTo(SHEventIdentifier pkgType, ReceiverPtr receiver)
{ {
SHEventManager::GetEventManagerInstance().RegisterReceiverToType(pkgType, receiver); RegisterReceiverToType(pkgType, receiver);
} }
template<typename T> template<typename T>
T* SHEventManager::BroadcastData(T data, SHEventIdentifier eventType) T* SHEventManager::BroadcastEvent(T data, SHEventIdentifier eventType)
{ {
SHEventDataPtr ptr = new std::byte[sizeof(data)]; SHEventDataPtr ptr = new std::byte[sizeof(data)];
@ -133,10 +104,10 @@ namespace SHADE
ResponseVec& receivers{ packageReceiverRegistry[event.type] }; ResponseVec& receivers{ packageReceiverRegistry[event.type] };
for (auto& receiver : receivers) for (auto& receiver : receivers)
{ {
receiver->Receive(event.data); receiver->Receive(event);
} }
//auto& funcs{ staticPackageReceiverRegistry[event.GetType()] }; //auto& funcs{ ackageReceiverRegistry[event.GetType()] };
//for (auto func : funcs) //for (auto func : funcs)
//{ //{
// func(event.GetData()); // func(event.GetData());

52
SHADE_Engine/src/Events/SHEventManager.h
View File

@ -3,21 +3,26 @@
* \author Loh Xiao Qi * \author Loh Xiao Qi
* \brief Class declaration for event manager. * \brief Class declaration for event manager.
* *
* \copyright Copyright (c) 2021 Digipen Institute of Technology. Reproduction * \copyright Copyright (c) 2022 Digipen Institute of Technology. Reproduction
* or disclosure of this file or its contents without the prior written consent * or disclosure of this file or its contents without the prior written consent
* of Digipen Institute of Technology is prohibited. * of Digipen Institute of Technology is prohibited.
******************************************************************************/ ******************************************************************************/
#ifndef SH_EVENT_MANAGER_H #pragma once
#define SH_EVENT_MANAGER_H
#include "SHEvent.h" #include "SHEvent.h"
#include "SHEventReceiver.h" #include "SHEventReceiver.h"
#include <unordered_map> #include <unordered_map>
#include <functional> #include <functional>
/******************************************************************************
INSTRUCTIONS FOR USE:
On broadcaster side:
1.
******************************************************************************/
namespace SHADE namespace SHADE
{ {
using ResponseFunction = std::function<void(SHEvent)>; using ResponseFunction = std::function<SHEventHandle(SHEvent)>;
using ReceiverPtr = std::shared_ptr<SHEventReceiver>; using ReceiverPtr = std::shared_ptr<SHEventReceiver>;
using ResponseVec = std::vector<ReceiverPtr>; using ResponseVec = std::vector<ReceiverPtr>;
using StaticResponseVec = std::vector<ResponseFunction>; using StaticResponseVec = std::vector<ResponseFunction>;
@ -27,29 +32,11 @@ namespace SHADE
class SHEventManager class SHEventManager
{ {
public: public:
/**************************************************************************** /****************************************************************************
* \brief Ctor and Dtor. Dtor will delete instance of self stored at
* data member instance.
****************************************************************************/
SHEventManager();
/****************************************************************************
* \brief Returns singleton instance of event manager in heap memory. If
* instance does not exist, one is created immediately.
****************************************************************************/
static SHEventManager& GetEventManagerInstance();
/****************************************************************************
* \brief Returns function pointer to entry point for events. * \brief Returns function pointer to entry point for events.
****************************************************************************/ ****************************************************************************/
static EventManagerListener GetListenerFunction(); static EventManagerListener GetListenerFunction();
/****************************************************************************
* \brief Exit function to terminate the manager properly and deallocate
* memory.
****************************************************************************/
static void Exit();
/**************************************************************************** /****************************************************************************
* \param ListenerConstPtr - Const pointer to listener that sent event. * \param ListenerConstPtr - Const pointer to listener that sent event.
* \param EventType - Templated type for every type of event * \param EventType - Templated type for every type of event
@ -67,19 +54,18 @@ namespace SHADE
* \brief Links a function pointer from a subscriber to a particular * \brief Links a function pointer from a subscriber to a particular
* package type * package type
****************************************************************************/ ****************************************************************************/
void SubscribeTo(SHEventIdentifier, ReceiverPtr); static void SubscribeTo(SHEventIdentifier, ReceiverPtr);
template<typename T> template<typename T>
T* BroadcastData(T data, SHEventIdentifier eventType); static T* BroadcastEvent(T data, SHEventIdentifier eventType);
private: private:
// Singleton instance
static SHEventManager* instance;
// Registry for broadcasters and subscribers // Registry for broadcasters and subscribers
std::unordered_map<SHEventIdentifier, ResponseVec> packageReceiverRegistry; static std::unordered_map<SHEventIdentifier, ResponseVec> packageReceiverRegistry;
std::unordered_map<SHEventHandle, SHEventDataPtr> dataEventMap; static std::unordered_map<SHEventHandle, SHEventDataPtr> dataEventMap;
SHEventHandle handleCounter; static SHEventHandle handleCounter;
/**************************************************************************** /****************************************************************************
* \param ListenerConstPtr - Const pointer to listener that sent event. * \param ListenerConstPtr - Const pointer to listener that sent event.
@ -88,7 +74,7 @@ namespace SHADE
* \brief Broadcast event to all receivers that are subscribed to this * \brief Broadcast event to all receivers that are subscribed to this
* listener. * listener.
****************************************************************************/ ****************************************************************************/
void Broadcast(SHEvent const&); static void Broadcast(SHEvent const&);
/**************************************************************************** /****************************************************************************
* \param ReceiverPtr - Pointer to receiver * \param ReceiverPtr - Pointer to receiver
@ -97,9 +83,7 @@ namespace SHADE
* \brief Registers receiver as a subscriber to listener in the registry. * \brief Registers receiver as a subscriber to listener in the registry.
****************************************************************************/ ****************************************************************************/
void RegisterReceiverToType(SHEventIdentifier, ReceiverPtr); static void RegisterReceiverToType(SHEventIdentifier, ReceiverPtr);
}; };
} }
#endif // !SH_EVENTS_MANAGER_H

10
SHADE_Engine/src/Events/SHEventReceiver.h
View File

@ -1,5 +1,4 @@
#ifndef SH_EVENT_RECEIVER_H #pragma once
#define SH_EVENT_RECEIVER_H
#include "SHEvent.h" #include "SHEvent.h"
@ -9,7 +8,7 @@ namespace SHADE
{ {
private: private:
public: public:
virtual void Receive(SHEventDataPtr) = 0; virtual void Receive(SHEvent) = 0;
}; };
template<typename T> template<typename T>
@ -17,7 +16,7 @@ namespace SHADE
{ {
private: private:
T* object; T* object;
void(T::*callback)(SHEventDataPtr); SHEventHandle(T::*callback)(SHEvent);
public: public:
SHEventReceiverSpec(T* obj, void(T::* cb)(SHEventDataPtr)) SHEventReceiverSpec(T* obj, void(T::* cb)(SHEventDataPtr))
@ -26,10 +25,9 @@ namespace SHADE
} }
void Receive(SHEventDataPtr evt) override void Receive(SHEvent evt) override
{ {
(object->*callback)(evt); (object->*callback)(evt);
} }
}; };
} }
#endif // !SH_EVENT_RECEIVER_H