YiEventDispatcher.h

Go to the documentation of this file.

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

#include "binding/YiScriptableObject.h"
#include "framework/YiPredef.h"
#include "event/YiDeferredDeletionEvent.h"
#include "event/YiEvent.h"
#include "logging/YiLoggerHelper.h"
#include "signal/YiSignalHandler.h"
#include "thread/YiThread.h"
#include "thread/YiMutex.h"
#include "thread/YiReadWriteMutex.h"
#include "thread/YiWaitCondition.h"
#include "utility/YiPriorityQueue.h"

#include <memory>

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

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>, public CYIScriptableObject
{
    friend class CYIEventHandler;

    typedef std::vector<std::shared_ptr<CYIEventHandlerProxy>> YI_EVENT_HANDLER_LIST;
    typedef std::vector<std::shared_ptr<CYIEventFilterProxy>> YI_EVENT_FILTER_LIST;
    typedef std::vector<IYIEventDispatcherListener *> YI_EVENT_DISPATCHER_LISTENER_LIST;
    typedef CYIPriorityQueue<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:

    CYIEventDispatcher();
    virtual ~CYIEventDispatcher();

    bool Start();

    bool Exit(bool bJoin = false, bool bWaitUntilEmpty = false);
    
    void WaitUntilEventQueueRunning();

    bool WaitUntilEventPosted(uint64_t uTimeoutMs = 0);

    bool ProcessOneEvent();
    
    bool ProcessAllEvents();
    
    bool ProcessAllEvents(uint64_t uTimeoutUs);

    bool RegisterEventHandler(CYIEventHandler *pEventHandler);
    
    bool UnregisterEventHandler(CYIEventHandler *pEventHandler);
    
    bool RegisterEventFilter(CYIEventFilter *pEventFilter);
    
    bool UnregisterEventFilter(CYIEventFilter *pEventFilter);

    bool RegisterEventDispatcherListener(IYIEventDispatcherListener *pEventDispatcherListener);
    
    bool UnregisterEventDispatcherListener(IYIEventDispatcherListener *pEventDispatcherListener);
    
    bool PostEvent(std::unique_ptr<CYIEvent> pEvent, YI_EVENT_PRIORITY priority = YI_EVENT_PRIORITY_DEFAULT, bool bBump = false);

    bool PostEvent(std::unique_ptr<CYIEvent> pEvent, CYIEventHandler *pDestination, YI_EVENT_PRIORITY priority = YI_EVENT_PRIORITY_DEFAULT, bool bBump = false);

    bool PostUniqueEvent(std::unique_ptr<CYIEvent> pEvent, YI_EVENT_PRIORITY priority = YI_EVENT_PRIORITY_DEFAULT);

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

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

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

    int32_t GetEventCount() const;

    void Shutdown();
    
    void DiscardAllPosts();
    
    void DiscardPosts(CYIEventHandler *pDestination);
    
    
    void DiscardPostsIf(bool (*predicate)(const std::shared_ptr<CYIEventDispatcher> &, CYIEvent *, CYIEventHandler *, YI_EVENT_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);

    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_bEventQueueRunning;

    CYISignalEmitEventHandler *m_pSignalEmitEventHandler;
    CYIDeferredDeletionEventHandler *m_pDeferredDeletionEventHandler;
    CYITaskEventHandler *m_pTaskEventHandler;

    YI_EVENT_HANDLER_LIST m_eventHandlerList;
    YI_EVENT_FILTER_LIST m_eventFilterList;
    YI_EVENT_DISPATCHER_LISTENER_LIST m_eventDispatcherListenerList;
    YI_EVENT_QUEUE m_eventQueue;

    CYILazy<CYIMutex> m_eventHandlerListMutex;
    CYILazy<CYIMutex> m_eventFilterListMutex;
    CYILazy<CYIMutex> m_eventDispatcherListenerListMutex;

    mutable CYIMutex m_eventQueueMutex;
    CYIWaitCondition m_eventQueueWaitCondition;
    CYIWaitCondition 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(), YI_EVENT_PRIORITY_HIGHEST);
    }
}

#endif /* _YI_EVENT_DISPATCHER_H_ */