EventQueue Class Reference

Event queue. More...

#include <EventQueue.h>

Inheritance diagram for EventQueue:

Collaboration diagram for EventQueue:

Public Member Functions
	EventQueue ()
	EventQueue (EventQueue const &)=delete
	EventQueue (EventQueue &&)=delete
	~EventQueue () override
EventQueue &	operator= (EventQueue const &)=delete
EventQueue &	operator= (EventQueue &&)=delete
void	loop () override
	Loop the event queue until quit.
void	adoptBuffer (IEventQueueBuffer *) override
	Set the buffer.
bool	getEvent (Event &event, double timeout=-1.0) override
	Remove event from queue.
bool	dispatchEvent (const Event &event) override
	Dispatch an event.
void	addEvent (const Event &event) override
	Add event to queue.
EventQueueTimer *	newTimer (double duration, void *target) override
	Create a recurring timer.
EventQueueTimer *	newOneShotTimer (double duration, void *target) override
	Create a one-shot timer.
void	deleteTimer (EventQueueTimer *) override
	Destroy a timer.
void	addHandler (EventTypes type, void *target, const EventHandler &handler) override
	Register an event handler for an event type.
void	removeHandler (EventTypes type, void *target) override
	Unregister an event handler for an event type.
void	removeHandlers (void *target) override
	Unregister all event handlers for an event target.
bool	isEmpty () const override
	Test if queue is empty.
void *	getSystemTarget () override
	Get the system event type target.
void	waitForReady () const override
	Wait for event queue to become ready.
Public Member Functions inherited from IEventQueue
Public Member Functions inherited from IInterface
virtual	~IInterface ()=default
	Interface destructor does nothing.

Additional Inherited Members
Public Types inherited from IEventQueue
using	EventHandler = std::function<void(const Event &)>

Detailed Description

Event queue.

An event queue that implements the platform independent parts and delegates the platform dependent parts to a subclass.

Constructor & Destructor Documentation

EventQueue() [1/3]

EventQueue::EventQueue

(

)

EventQueue() [2/3]

EventQueue::EventQueue ( EventQueue const & )

delete

EventQueue() [3/3]

EventQueue::EventQueue ( EventQueue && )

delete

~EventQueue()

EventQueue::~EventQueue ( )

override

Member Function Documentation

addEvent()

void EventQueue::addEvent ( const Event & event )

overridevirtual

Add event to queue.

Adds event to the end of the queue.

Implements IEventQueue.

addHandler()

void EventQueue::addHandler ( EventTypes type, void * target, const EventHandler & handler )

overridevirtual

Register an event handler for an event type.

Registers an event handler for type and target. The handler is adopted. Any existing handler for the type,target pair is deleted. dispatchEvent() will invoke handler for any event for target of type type. If no such handler exists it will use the handler for target and type kUnknown if it exists.

Implements IEventQueue.

adoptBuffer()

void EventQueue::adoptBuffer ( IEventQueueBuffer * )

overridevirtual

Set the buffer.

Replace the current event queue buffer. Any queued events are discarded. The queue takes ownership of the buffer.

Implements IEventQueue.

deleteTimer()

void EventQueue::deleteTimer ( EventQueueTimer * )

overridevirtual

Destroy a timer.

Destroys a previously created timer. The timer is removed from the queue and will not generate event, even if the timer has expired.

Implements IEventQueue.

dispatchEvent()

bool EventQueue::dispatchEvent ( const Event & event )

overridevirtual

Dispatch an event.

Looks up the dispatcher for the event's target and invokes it. Returns true iff a dispatcher exists for the target.

The caller must ensure that the target of the event is not removed by removeHandler() or removeHandlers().

Implements IEventQueue.

getEvent()

bool EventQueue::getEvent ( Event & event, double timeout = -1.0 )

overridevirtual

Remove event from queue.

Returns the next event on the queue into event. If no event is available then blocks for up to timeout seconds, or forever if timeout is negative. Returns true iff an event was available.

Implements IEventQueue.

getSystemTarget()

void * EventQueue::getSystemTarget ( )

overridevirtual

Get the system event type target.

Returns the target to use for dispatching EventTypes::System events.

Implements IEventQueue.

isEmpty()

bool EventQueue::isEmpty ( ) const

overridevirtual

Test if queue is empty.

Returns true iff the queue has no events in it, including timer events.

Implements IEventQueue.

loop()

void EventQueue::loop ( )

overridevirtual

Loop the event queue until quit.

Dequeues and dispatches events until the kQuit event is found.

Implements IEventQueue.

newOneShotTimer()

EventQueueTimer * EventQueue::newOneShotTimer ( double duration, void * target )

overridevirtual

Create a one-shot timer.

Creates and returns a one-shot timer. An event is returned when the timer expires and the timer is removed from further handling. When a timer event is returned the data points to a TimerEvent. The c_count member of the TimerEvent is always 1. The client must pass the returned timer to deleteTimer() (whether or not the timer has expired) to release the timer. The returned timer event uses the given target. If target is nullptr it uses the returned timer as the target.

Implements IEventQueue.

newTimer()

EventQueueTimer * EventQueue::newTimer ( double duration, void * target )

overridevirtual

Create a recurring timer.

Creates and returns a timer. An event is returned after duration seconds and the timer is reset to countdown again. When a timer event is returned the data points to a TimerEvent. The client must pass the returned timer to deleteTimer() (whether or not the timer has expired) to release the timer. The returned timer event uses the given target. If target is nullptr it uses the returned timer as the target.

Events for a single timer don't accumulate in the queue, even if the client reading events can't keep up. Instead, the m_count member of the TimerEvent indicates how many events for the timer would have been put on the queue since the last event for the timer was removed (or since the timer was added).

Implements IEventQueue.

operator=() [1/2]

EventQueue & EventQueue::operator= ( EventQueue && )

delete

operator=() [2/2]

EventQueue & EventQueue::operator= ( EventQueue const & )

delete

removeHandler()

void EventQueue::removeHandler ( EventTypes type, void * target )

overridevirtual

Unregister an event handler for an event type.

Unregisters an event handler for the type, target pair and deletes it.

Implements IEventQueue.

removeHandlers()

void EventQueue::removeHandlers ( void * target )

overridevirtual

Unregister all event handlers for an event target.

Unregisters all event handlers for the target and deletes them.

Implements IEventQueue.

waitForReady()

void EventQueue::waitForReady ( ) const

overridevirtual

Wait for event queue to become ready.

Blocks on the current thread until the event queue is ready for events to be added.

Implements IEventQueue.

---

The documentation for this class was generated from the following files:

• src/lib/base/EventQueue.h
• src/lib/base/EventQueue.cpp