#ifndef events_hh
#define events_hh

#include "CThread.h"
#include <queue>

class ss_event_base {
	int type;
};

class ss_event : public ss_event_base {


};

typedef std::queue<ss_event_base *> evt_queue;

/*
 * RAII mutex class
 */
struct mutex_locker
{
	 mutex_locker(mutex& mutex) : _m(mutex) { _m.lock(); }
	~mutex_locker() { _m.unlock(); }

	mutex &_m;
};

struct event_manager : public CThread
{
	static event_manager &get() { static event_manager e; return e; }

	void enque_event(ss_event_base *e);
private:
	event_manager() {}

	ss_event_base *pop_queue();
	void execute(void *parm);

private:
	mutex em;
	evt_queue eq;
};

#endif // enets_hh
---------------

/*
 * events.cc
 *
 * unique event processing
 *
 */

#include "events.hh"

void event_manager::enque_event(ss_event_base *e)
{
	mutex_locker lock(em);

	eq.push(e);
}

/*
 * utility function to check the queue with minimal locking
 */
ss_event_base *event_manager::pop_queue()
{
	mutex_locker lock(em);

	if (eq.empty()) return 0;

	ss_event_base *e = eq.front();
	eq.pop();

	return e;
}

void event_manager::execute(void *parm)
{
	ss_event_base *e;

	for (;;) {

		while ((e = pop_queue()) != 0) {

			/* process the event here */

			/* delete it eventually */
			delete (e);
		}

		usleep(100000);
	}
}