YiEventDispatcher.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2020. All rights reserved.
#ifndef _YI_EVENT_DISPATCHER_H_
#define _YI_EVENT_DISPATCHER_H_

#include "event/YiDeferredDeletionEvent.h"
#include "event/YiEvent.h"
#include "framework/YiPredef.h"
#include "logging/YiLogger.h"
#include "signal/YiSignalHandler.h"
#include "thread/YiReadWriteMutex.h"
#include "thread/YiThread.h"

#include <condition_variable>
#include <memory>
#include <mutex>

class CYIEventDispatcher;
class CYIEventHandler;
class CYIEventHandlerProxy;
class CYIEventFilter;
class CYIEventFilterProxy;
class CYISignalEmitEventHandler;
class CYIDeferredDeletionEventHandler;
class CYITaskEventHandler;

enum class EYIPriorityQueuePriority;
template<typename YI_PRIORITY_QUEUE_ITEM, class YI_PRIORITY_QUEUE_ALLOCATOR>
class CYIPriorityQueue;

class IYIEventDispatcherListener
{
public:
    IYIEventDispatcherListener() {}
    virtual ~IYIEventDispatcherListener() {}

    virtual void EventLoopStarted(const std::shared_ptr<CYIEventDispatcher> &pDispatcher) = 0;

    virtual void EventLoopExited(const std::shared_ptr<CYIEventDispatcher> &pDispatcher) = 0;

    virtual void EventDispatchStarted(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) = 0;

    virtual void EventDispatchEnded(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent) = 0;

    virtual void EventPreFilteredByDispatcher(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYIEventFilter *pFilter) = 0;

    virtual void EventPreFilteredByHandler(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYIEventFilter *pFilter, CYIEventHandler *pHandler) = 0;

    virtual void EventHandled(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYIEventHandler *pHandler) = 0;

    virtual void EventPostFilteredByHandler(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYIEventFilter *pFilter, CYIEventHandler *pHandler) = 0;

    virtual void EventPostFilteredByDispatcher(const std::shared_ptr<CYIEventDispatcher> &pDispatcher, CYIEvent *pEvent, CYIEventFilter *pFilter) = 0;
};

class CYIEventDispatcher : public CYISignalHandler, public std::enable_shared_from_this<CYIEventDispatcher>
{
    friend class CYIEventHandler;

    typedef std::deque<std::shared_ptr<CYIEventHandlerProxy>> YI_EVENT_HANDLER_LIST;
    typedef std::deque<std::shared_ptr<CYIEventFilterProxy>> YI_EVENT_FILTER_LIST;
    typedef std::deque<IYIEventDispatcherListener *> YI_EVENT_DISPATCHER_LISTENER_LIST;
    typedef CYIPriorityQueue<std::pair<std::unique_ptr<CYIEvent>, std::shared_ptr<CYIEventHandlerProxy>>, std::allocator<std::pair<EYIPriorityQueuePriority, std::pair<std::unique_ptr<CYIEvent>, std::shared_ptr<CYIEventHandlerProxy>>>>> YI_EVENT_QUEUE;
    typedef std::vector<std::pair<CYIThreadHandle, std::shared_ptr<CYIEventDispatcher>>> YI_DISPATCHER_MAP;

public:
    enum class Priority
    {
        High, 
        Low 
    };

    CYIEventDispatcher();
    virtual ~CYIEventDispatcher();

    bool Start();

    bool Exit(bool join = false, bool waitUntilEmpty = false);

    void WaitUntilEventQueueRunning();

    bool WaitUntilEventPosted(uint64_t timeoutMs = 0);

    bool ProcessOneEvent();

    bool ProcessAllEvents();

    bool ProcessAllEvents(uint64_t timeoutUs);

    bool ProcessEventsOfType(CYIEvent::Type type);

    bool ProcessEventsOfTypes(const std::vector<CYIEvent::Type> &types);

    bool RegisterEventHandler(CYIEventHandler *pEventHandler, Priority priority = Priority::Low);

    bool UnregisterEventHandler(CYIEventHandler *pEventHandler);

    bool RegisterEventFilter(CYIEventFilter *pEventFilter, Priority priority = Priority::Low);

    bool UnregisterEventFilter(CYIEventFilter *pEventFilter);

    bool RegisterEventDispatcherListener(IYIEventDispatcherListener *pEventDispatcherListener, Priority priority = Priority::Low);

    bool UnregisterEventDispatcherListener(IYIEventDispatcherListener *pEventDispatcherListener);

    bool PostEvent(std::unique_ptr<CYIEvent> pEvent, CYIEvent::Priority priority = CYIEvent::Priority::Default, bool bump = false);

    bool PostEvent(std::unique_ptr<CYIEvent> pEvent, CYIEventHandler *pDestination, CYIEvent::Priority priority = CYIEvent::Priority::Default, bool bump = false);

    bool PostUniqueEvent(std::unique_ptr<CYIEvent> pEvent, CYIEvent::Priority priority = CYIEvent::Priority::Default);

    bool PostUniqueEvent(std::unique_ptr<CYIEvent> pEvent, CYIEventHandler *pDestination, CYIEvent::Priority priority = CYIEvent::Priority::Default);

    bool SendEvent(std::unique_ptr<CYIEvent> pEvent);

    bool SendEvent(std::unique_ptr<CYIEvent> pEvent, CYIEventHandler *pDestination);

    size_t GetEventCount() const;

    void Shutdown();

    void DiscardAllPosts();

    void DiscardPosts(CYIEventHandler *pDestination);

    void DiscardPostsIf(bool (*predicate)(const std::shared_ptr<CYIEventDispatcher> &, CYIEvent *, CYIEventHandler *, CYIEvent::Priority));

    static std::shared_ptr<CYIEventDispatcher> GetDispatcher(const CYIThreadHandle &threadAffinity);

    static const std::shared_ptr<CYIEventDispatcher> &GetDefaultDispatcher();

    static const CYIThreadHandle &GetDefaultDispatcherThreadAffinity();

    static const std::shared_ptr<CYIEventDispatcher> &GetDrawDispatcher();

    static void SetDispatcher(const CYIThreadHandle &threadAffinity, const std::shared_ptr<CYIEventDispatcher> &pDispatcher);

    static void RemoveDispatcher(const CYIThreadHandle &threadAffinity);

    static void SetDefaultDispatcher(const std::shared_ptr<CYIEventDispatcher> &pDispatcher);

    static void RemoveDefaultDispatcher();

    static void SetDrawDispatcher(const std::shared_ptr<CYIEventDispatcher> &pDispatcher);

    static void RemoveDrawDispatcher();

    CYIEventHandler *GetSignalEmitEventHandler();

    CYIEventHandler *GetDeferredDeletionEventHandler();

    CYIEventHandler *GetTaskEventHandler();

private:
    CYIEventDispatcher(const CYIEventDispatcher &);
    CYIEventDispatcher &operator=(const CYIEventDispatcher &);

    bool PreFilter(CYIEvent *pEvent, const std::shared_ptr<CYIEventHandlerProxy> &pDestination);
    bool PostFilter(CYIEvent *pEvent, const std::shared_ptr<CYIEventHandlerProxy> &pDestination);
    bool DispatchEvent(CYIEvent *pEvent, const std::shared_ptr<CYIEventHandlerProxy> &pDestination);
    bool ProcessEvent(CYIEvent *pEvent, const std::shared_ptr<CYIEventHandlerProxy> &pDestination);

    bool ProcessEventsOfTypes(const CYIEvent::Type *pFirstItem, size_t count);

    void NotifyEventLoopStarted();
    void NotifyEventLoopExited();
    void NotifyEventDispatchStarted(CYIEvent *pEvent);
    void NotifyEventDispatchEnded(CYIEvent *pEvent);
    void NotifyEventPreFilteredByDispatcher(CYIEvent *pEvent, CYIEventFilter *pFilter);
    void NotifyEventPreFilteredByHandler(CYIEvent *pEvent, CYIEventFilter *pFilter, CYIEventHandler *pHandler);
    void NotifyEventHandled(CYIEvent *pEvent, CYIEventHandler *pHandler);
    void NotifyEventPostFilteredByHandler(CYIEvent *pEvent, CYIEventFilter *pFilter, CYIEventHandler *pHandler);
    void NotifyEventPostFilteredByDispatcher(CYIEvent *pEvent, CYIEventFilter *pFilter);

    bool m_eventQueueRunning;

    std::unique_ptr<CYISignalEmitEventHandler> m_pSignalEmitEventHandler;
    std::unique_ptr<CYIDeferredDeletionEventHandler> m_pDeferredDeletionEventHandler;
    std::unique_ptr<CYITaskEventHandler> m_pTaskEventHandler;

    YI_EVENT_HANDLER_LIST m_eventHandlerList;
    YI_EVENT_FILTER_LIST m_eventFilterList;
    YI_EVENT_DISPATCHER_LISTENER_LIST m_eventDispatcherListenerList;
    std::unique_ptr<YI_EVENT_QUEUE> m_pEventQueue;

    CYILazy<std::mutex> m_eventHandlerListMutex;
    CYILazy<std::mutex> m_eventFilterListMutex;
    CYILazy<std::mutex> m_eventDispatcherListenerListMutex;

    mutable std::mutex m_eventQueueMutex;
    std::condition_variable m_eventQueueWaitCondition;
    std::condition_variable m_waitUntilEventWaitCondition;

    static YI_DISPATCHER_MAP s_dispatcherMap;
    static std::shared_ptr<CYIEventDispatcher> s_dispatcherDefault;
    static CYIThreadHandle s_dispatcherDefaultThreadAffinity;
    static std::shared_ptr<CYIEventDispatcher> s_dispatcherDraw;
    static CYIReadWriteMutex s_dispatcherMapMutex;
};

template<typename YI_TYPE>
inline void YiDeleteLater(std::unique_ptr<YI_TYPE> pPtr)
{
    if (pPtr)
    {
        std::shared_ptr<CYIEventDispatcher> pDispatcher = CYIEventDispatcher::GetDispatcher(CYIThread::GetCurrentThreadId());
        if (!pDispatcher)
        {
            pDispatcher = CYIEventDispatcher::GetDefaultDispatcher();
        }

        if (!pDispatcher)
        {
            YI_LOGD("YiDeleteLater", "No event dispatcher. YiDeleteLater called while the application is shutting down, so deleting ptr immediately.");
            // If we can't delete later, we have to delete now to avoid a memory leak. This will occur during shutdown when the CYIDeferredDeletionEvent is deleting the pPtr, and it in turn results in a YiDeleteLater being called.
            pPtr.reset();
            return;
        }

        pDispatcher->PostEvent(std::unique_ptr<CYIEvent>(new CYIDeferredDeletionEvent<YI_TYPE>(std::move(pPtr))), pDispatcher->GetDeferredDeletionEventHandler(), CYIEvent::Priority::Highest);
    }
}

#endif /* _YI_EVENT_DISPATCHER_H_ */