EventLogService.h

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#pragma once
 
#include "Events/BaseEvent.h"
 
class EventContainer
{
    friend class EventLogService;
 
    EventContainer()
    {
    }
 
public:
    EventContainer(EventContainer& Other) = delete;
    void operator=(const EventContainer&) = delete;
 
    bool GetAll(TArray<UBaseEvent*>& OutEvents);
    FORCEINLINE int32 Size() { return GetBuffer().Num(); };
 
    FORCEINLINE bool Add(UBaseEvent* NewEvent)
    {
        if (NewEvent && NewEvent->Lock())
        {
            GetBuffer().Add(NewEvent);
            return true;
        }
        return false;
    }
 
private:
    FORCEINLINE TArray<UBaseEvent*>& GetBuffer()
    {
        return FirstBufferInUse ? FirstBuffer : SecondBuffer;
    }
 
    void Swap();
 
private:
    TArray<UBaseEvent*> FirstBuffer;
    TArray<UBaseEvent*> SecondBuffer;
 
    bool FirstBufferInUse = true;
};
 
class PIXOCORE_API EventLogService
{
    friend class UExperienceManager;
 
    EventLogService()
    {
    };
 
public:
    EventLogService(EventLogService& Other) = delete;
    void operator=(const EventLogService&) = delete;
 
    template <typename TEventType>
    FUNCTION_NON_NULL_RETURN_START
    static TEventType* NewEvent(APlayerController* Executor = nullptr)
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "TEventType should derive from UBaseEvent");
 
        TEventType* Event = NewObject<TEventType>();
        if (Events().Add(Event))
        {
            Event->Initialize(Executor);
        }
        return Event;
    }
 
    template <typename TEventType>
    FUNCTION_NON_NULL_RETURN_START
    static TEventType* NewEvent(UObject* Outer, UClass* TargetEventClass, APlayerController* Executor = nullptr)
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "TEventType should derive from UBaseEvent");
 
        TEventType* Event = NewObject<TEventType>(Outer, TargetEventClass);
        if (Events().Add(Event))
        {
            Event->Initialize(Executor);
        }
        return Event;
    }
 
    template <typename TEventType, typename... TInitializeArgs>
    FUNCTION_NON_NULL_RETURN_START
    static TEventType* NewEvent(UObject* Outer, UClass* TargetEventClass, APlayerController* Executor, TInitializeArgs... Arguments)
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "TEventType should derive from UBaseEvent");
 
        TEventType* Event = NewObject<TEventType>(Outer, TargetEventClass);
        if (Events().Add(Event))
        {
            Event->Initialize(Executor, Arguments...);
        }
        return Event;
    }
 
    template <typename TEventType, typename... TInitializeArgs>
    FUNCTION_NON_NULL_RETURN_START
    static TEventType* NewEvent(UObject* Outer, UClass* TargetEventClass, TInitializeArgs... Arguments)
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "TEventType should derive from UBaseEvent");
 
        TEventType* Event = NewObject<TEventType>(Outer, TargetEventClass);
        if (Events().Add(Event))
        {
            Event->Initialize(nullptr, Arguments...);
        }
        return Event;
    }
 
    template <typename TEventType, typename... TInitializeArgs>
    FUNCTION_NON_NULL_RETURN_START
    static TEventType* NewEvent(APlayerController* Executor, TInitializeArgs... Arguments)
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(std::is_base_of<UBaseEvent, TEventType>::value, "TEventType should derive from UBaseEvent");
 
        TEventType* Event = NewObject<TEventType>();
        if (Events().Add(Event))
        {
            Event->Initialize(Executor, Arguments...);
        }
        return Event;
    }
 
private:
    static EventContainer& Events();
};