PDG_EventEmitter.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __PDG_EVENT_EMITTER_H__
#define __PDG_EVENT_EMITTER_H__

#include "PDG_API.h"

#include "PDG_EventTypes.h"

#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_TBBSpinLock.h>

class PDG_EventHandler;
class PDG_Event;
class PDG_EventQueue;

class PDG_API PDG_EventEmitter
{
public:
    using Filter        = UT_ValArray<PDG_EventType>;
    using FilterMap     = UT_ArrayMap<PDG_EventHandler *, Filter>;
    using HandlerSet    = UT_ArraySet<PDG_EventHandler *>;
    using HandlerArray  = UT_Array<PDG_EventHandler *>;

public:
                            PDG_EventEmitter(PDG_EventQueue* eventQueue,
                                             bool block_destruction);
    virtual                 ~PDG_EventEmitter();

    /// Returns the list of supported event types for this emitter
    virtual Filter&         supportedEventTypes() const = 0;

    /// Returns memory usage for this event emitter instance
    int64                   getMemoryUsage(bool inclusive) const;

    /// Adds an event handlers that listens for all types of events
    bool                    addEventHandler(PDG_EventHandler* handler);

    /// Adds an event handlers that listens for a specific event
    bool                    addEventHandler(PDG_EventHandler* handler,
                                            PDG_EventType event);

    /// Adds an event handler with a filter, so that it only listens for
    /// events in the specified list
    bool                    addEventHandler(PDG_EventHandler* handler,
                                            const Filter& filter);

    /// Removes an event handler from this emitter
    void                    removeEventHandler(PDG_EventHandler* handler);

    /// Removes all event handlers from this emitter. If user_handler_only
    /// is true, only user-added event handlers are removed.
    void                    removeAllEventHandlers(
                                        bool user_handler_only = false);

    /// Emit an event to all handlers
    void                    emitEvent(const PDG_Event& evt) const;

    /// Safely makes a copy of the list of handlers. If this emitter is
    /// currently being destroyed, the resulting array is empty
    void                    eventHandlers(HandlerArray& handlers) const;

    void                    setEventQueue(PDG_EventQueue* eventQueue);
    void                    eventQueueDestroyed();

protected:
    HandlerSet              myHandlers;
    FilterMap               myFilters;
    mutable UT_TBBSpinLock  myHandlersLock;
    bool                    myBeingDestroyedFlag = false;


private:
    void doEmitEvent(const PDG_Event& evt) const;

    PDG_EventQueue* myEventQueue = nullptr;
    bool myWaitEventsWhenDestroyed = false;

    friend class PDG_EventQueue;
};

#endif