BaseManager.h

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#pragma once
 
#include <unordered_map>
#include "CoreMinimal.h"
#include "EventLogService.h"
#include "UObject/Object.h"
#include "BaseManager.generated.h"
 
#define DECLARE_EVENT_HANDLER(TEvent) protected: void HandleEvent_Impl(class TEvent* Event);
 
#define DEFINE_EVENT_HANDLER(TEventType)                                                                            \
static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "Trying to create definiton for invalid event");      \
Handlers[TEventType::StaticClass()] = [this](UBaseEvent* Event) -> void                                             \
{                                                                                                                   \
HandleEvent_Impl(Cast<TEventType>(Event));                                                                          \
};
 
class UBaseEvent;
 
PRAGMA_DISABLE_OPTIMIZATION
 
UCLASS(/*Abstract*/)
class PIXOCORE_API UBaseManager : public UObject
{
    GENERATED_BODY()
    DECLARE_EVENT_HANDLER(UBaseEvent);
 
public:
    UBaseManager();
 
    template <typename TEventType, typename... TInitializeArgs>
    void SendEvent(TInitializeArgs... Arguments)
    {
        EventLogService::NewEvent<TEventType>(Arguments...);
    }
 
    void HandleEvent(UBaseEvent* Event);
    void SetPrivateOwner(APlayerController* Owner) { PrivateOwner = Owner; }
    APlayerController* GetPrivateOwner() const { return PrivateOwner; }
 
private:
    UPROPERTY()
    APlayerController* PrivateOwner;
 
    using THandlerKey = UClass*;
    using THandler = TFunction<void(UBaseEvent*)>;
 
    struct THandlerHash
    {
        std::size_t operator()(THandlerKey code) const
        {
            return sizeof(code);
        }
    };
 
    struct THandlerComp
    {
        bool operator()(THandlerKey lhs, THandlerKey rhs) const
        {
            return lhs == rhs;
        }
    };
 
    using THandlers = std::unordered_map<THandlerKey, THandler, THandlerHash, THandlerComp>;
 
protected:
    THandlers Handlers;
};
 
PRAGMA_ENABLE_OPTIMIZATION
 
template <typename TManagerType>
FUNCTION_NON_NULL_RETURN_START
TManagerType* NewManager(APlayerController* Owner, UClass* TargetManagerClass)
FUNCTION_NON_NULL_RETURN_END
{
    static_assert(std::is_base_of<UBaseManager, TManagerType>::value, "TManagerType should derive from UBaseManager");
    TManagerType* Manager = NewObject<TManagerType>(Owner, TargetManagerClass);
    Manager->SetPrivateOwner(Owner);
    return Manager;
}