+#ifndef SWIFTEN_Deleter_H

+#define SWIFTEN_Deleter_H

+

+#include <cassert>

+

+namespace Swift {

+ template<typename T>

+ class Deleter {

+ public:

+ Deleter(T* object) : object_(object) {

+ }

+

+ void operator()() {

+ assert(object_);

+ delete object_;

+ object_ = 0;

+ }

+

+ private:

+ T* object_;

+ };

+}

+#endif

+#ifndef SWIFTEN_DummyEventLoop_H

+#define SWIFTEN_DummyEventLoop_H

+

+#include <deque>

+#include <boost/function.hpp>

+

+#include "Swiften/EventLoop/EventLoop.h"

+#include "Swiften/Base/foreach.h"

+

+namespace Swift {

+ class DummyEventLoop : public EventLoop {

+ public:

+ DummyEventLoop() {

+ }

+

+ void processEvents() {

+ while (!events_.empty()) {

+ handleEvent(events_[0]);

+ events_.pop_front();

+ }

+ }

+

+ bool hasEvents() {

+ return events_.size() > 0;

+ }

+

+ virtual void post(const Event& event) {

+ events_.push_back(event);

+ }

+

+ private:

+ std::deque<Event> events_;

+ };

+}

+

+#endif

+

+#include "Swiften/EventLoop/EventLoop.h"

+

+#include <algorithm>

+#include <boost/bind.hpp>

+

+#include "Swiften/EventLoop/MainEventLoop.h"

+

+namespace Swift {

+

+EventLoop::EventLoop() : nextEventID_(0) {

+ MainEventLoop::setInstance(this);

+}

+

+EventLoop::~EventLoop() {

+ MainEventLoop::resetInstance();

+}

+

+void EventLoop::handleEvent(const Event& event) {

+ bool doCallback = false;

+ {

+ boost::lock_guard<boost::mutex> lock(eventsMutex_);

+ std::list<Event>::iterator i = std::find(events_.begin(), events_.end(), event);

+ if (i != events_.end()) {

+ doCallback = true;

+ events_.erase(i);

+ }

+ }

+ if (doCallback) {

+ event.callback();

+ }

+}

+

+void EventLoop::postEvent(boost::function<void ()> callback, void* owner) {

+ Event event(owner, callback);

+ {

+ boost::lock_guard<boost::mutex> lock(eventsMutex_);

+ event.id = nextEventID_;

+ nextEventID_++;

+ events_.push_back(event);

+ }

+ post(event);

+}

+

+void EventLoop::removeEventsFromOwner(void* owner) {

+ boost::lock_guard<boost::mutex> lock(eventsMutex_);

+ events_.remove_if(HasOwner(owner));

+}

+

+}

+#ifndef SWIFTEN_EventLoop_H

+#define SWIFTEN_EventLoop_H

+

+#include <boost/function.hpp>

+#include <boost/thread/mutex.hpp>

+#include <list>

+

+namespace Swift {

+ class EventLoop {

+ public:

+ EventLoop();

+ virtual ~EventLoop();

+

+ void postEvent(boost::function<void ()> event, void* owner);

+ void removeEventsFromOwner(void* owner);

+

+ protected:

+ struct Event {

+ Event(void* owner, const boost::function<void()>& callback) :

+ owner(owner), callback(callback) {

+ }

+

+ bool operator==(const Event& o) const {

+ return o.id == id;

+ }

+

+ unsigned int id;

+ void* owner;

+ boost::function<void()> callback;

+ };

+

+ /**

+ * Reimplement this to call handleEvent(event) from the thread in which

+ * the event loop is residing.

+ */

+ virtual void post(const Event& event) = 0;

+

+ void handleEvent(const Event& event);

+

+ private:

+ struct HasOwner {

+ HasOwner(void* owner) : owner(owner) {}

+ bool operator()(const Event& event) { return event.owner == owner; }

+ void* owner;

+ };

+ boost::mutex eventsMutex_;

+ unsigned int nextEventID_;

+ std::list<Event> events_;

+ };

+}

+

+#endif

+#include "Swiften/EventLoop/MainEventLoop.h"

+

+#include <iostream>

+

+namespace Swift {

+

+EventLoop* MainEventLoop::getInstance() {

+ if (!instance_) {

+ std::cerr << "No main event loop instantiated. Please instantiate the appropriate subclass of EventLoop (e.g. SimpleEventLoop, QtEventLoop) at the start of your application." << std::endl;

+ exit(-1);

+ }

+ return instance_;

+}

+

+void MainEventLoop::setInstance(EventLoop* loop) {

+ assert(!instance_);

+ instance_ = loop;

+}

+

+void MainEventLoop::resetInstance() {

+ assert(instance_);

+ instance_ = 0;

+}

+

+void MainEventLoop::postEvent(boost::function<void ()> event, void* owner) {

+ getInstance()->postEvent(event, owner);

+}

+

+void MainEventLoop::removeEventsFromOwner(void* owner) {

+ getInstance()->removeEventsFromOwner(owner);

+}

+

+EventLoop* MainEventLoop::instance_ = 0;

+

+}

+#ifndef SWIFTEN_MainEventLoop_H

+#define SWIFTEN_MainEventLoop_H

+

+#include <boost/function.hpp>

+

+#include "Swiften/EventLoop/Deleter.h"

+#include "Swiften/EventLoop/EventLoop.h"

+

+namespace Swift {

+ class EventLoop;

+

+ class MainEventLoop {

+ friend class EventLoop;

+

+ public:

+ /**

+ * Post an event from the given owner to the event loop.

+ * If the owner is destroyed, all events should be removed from the

+ * loop using removeEventsFromOwner().

+ */

+ static void postEvent(boost::function<void ()> event, void* owner = 0);

+

+ static void removeEventsFromOwner(void* owner);

+

+ template<typename T>

+ static void deleteLater(T* t) {

+ getInstance()->postEvent(Deleter<T>(t), 0);

+ }

+

+ private:

+ static void setInstance(EventLoop*);

+ static void resetInstance();

+ static EventLoop* getInstance();

+

+ private:

+ static EventLoop* instance_;

+ };

+}

+

+#endif

+SWIFTEN_SOURCES += \

+ Swiften/EventLoop/EventLoop.cpp \

+ Swiften/EventLoop/SimpleEventLoop.cpp \

+ Swiften/EventLoop/MainEventLoop.cpp

+

+include Swiften/EventLoop/UnitTest/Makefile.inc

+#include "Swiften/EventLoop/SimpleEventLoop.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Base/foreach.h"

+

+

+namespace Swift {

+

+void nop() {}

+

+SimpleEventLoop::SimpleEventLoop() : isRunning_(true) {

+}

+

+void SimpleEventLoop::run() {

+ while (isRunning_) {

+ std::vector<Event> events;

+ {

+ boost::unique_lock<boost::mutex> lock(eventsMutex_);

+ while (events_.size() == 0) {

+ eventsAvailable_.wait(lock);

+ }

+ events.swap(events_);

+ }

+ foreach(const Event& event, events) {

+ handleEvent(event);

+ }

+ }

+}

+

+void SimpleEventLoop::stop() {

+ postEvent(boost::bind(&SimpleEventLoop::doStop, this), 0);

+}

+

+void SimpleEventLoop::doStop() {

+ isRunning_ = false;

+}

+

+void SimpleEventLoop::post(const Event& event) {

+ {

+ boost::lock_guard<boost::mutex> lock(eventsMutex_);

+ events_.push_back(event);

+ }

+ eventsAvailable_.notify_one();

+}

+

+

+}

+#ifndef SWIFTEN_SimpleEventLoop_H

+#define SWIFTEN_SimpleEventLoop_H

+

+#include <vector>

+#include <boost/function.hpp>

+#include <boost/thread/mutex.hpp>

+#include <boost/thread/condition_variable.hpp>

+

+#include "Swiften/EventLoop/EventLoop.h"

+

+namespace Swift {

+ class SimpleEventLoop : public EventLoop {

+ public:

+ SimpleEventLoop();

+

+ void run();

+ void stop();

+

+ virtual void post(const Event& event);

+

+ private:

+ void doStop();

+

+ private:

+ bool isRunning_;

+ std::vector<Event> events_;

+ boost::mutex eventsMutex_;

+ boost::condition_variable eventsAvailable_;

+ };

+}

+#endif

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <boost/thread.hpp>

+#include <boost/bind.hpp>

+

+#include "Swiften/EventLoop/SimpleEventLoop.h"

+#include "Swiften/Base/sleep.h"

+

+using namespace Swift;

+

+class EventLoopTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(EventLoopTest);

+ CPPUNIT_TEST(testPost);

+ CPPUNIT_TEST(testRemove);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ EventLoopTest() {}

+

+ void setUp() {

+ events_.clear();

+ }

+

+ void testPost() {

+ SimpleEventLoop testling;

+

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 1), 0);

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 2), 0);

+ testling.stop();

+ testling.run();

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(events_.size()));

+ CPPUNIT_ASSERT_EQUAL(1, events_[0]);

+ CPPUNIT_ASSERT_EQUAL(2, events_[1]);

+ }

+

+ void testRemove() {

+ SimpleEventLoop testling;

+

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 1), &testling);

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 2), this);

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 3), &testling);

+ testling.postEvent(boost::bind(&EventLoopTest::logEvent, this, 4), this);

+ testling.removeEventsFromOwner(this);

+ testling.stop();

+ testling.run();

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(events_.size()));

+ CPPUNIT_ASSERT_EQUAL(1, events_[0]);

+ CPPUNIT_ASSERT_EQUAL(3, events_[1]);

+ }

+

+ private:

+ void logEvent(int i) {

+ events_.push_back(i);

+ }

+

+ private:

+ std::vector<int> events_;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(EventLoopTest);

+UNITTEST_SOURCES += \

+ Swiften/EventLoop/UnitTest/SimpleEventLoopTest.cpp \

+ Swiften/EventLoop/UnitTest/EventLoopTest.cpp

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <boost/thread.hpp>

+#include <boost/bind.hpp>

+

+#include "Swiften/EventLoop/SimpleEventLoop.h"

+#include "Swiften/Base/sleep.h"

+

+using namespace Swift;

+

+class SimpleEventLoopTest : public CppUnit::TestFixture

+{

+ CPPUNIT_TEST_SUITE(SimpleEventLoopTest);

+ CPPUNIT_TEST(testRun);

+ CPPUNIT_TEST(testPostFromMainThread);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ SimpleEventLoopTest() {}

+

+ void setUp() {

+ counter_ = 0;

+ }

+

+ void testRun() {

+ SimpleEventLoop testling;

+ boost::thread thread(boost::bind(&SimpleEventLoopTest::runIncrementingThread, this, &testling));

+ testling.run();

+

+ CPPUNIT_ASSERT_EQUAL(10, counter_);

+ }

+

+ void testPostFromMainThread() {

+ SimpleEventLoop testling;

+ testling.postEvent(boost::bind(&SimpleEventLoopTest::incrementCounterAndStop, this, &testling), 0);

+ testling.run();

+

+ CPPUNIT_ASSERT_EQUAL(1, counter_);

+ }

+

+ private:

+ void runIncrementingThread(SimpleEventLoop* loop) {

+ for (unsigned int i = 0; i < 10; ++i) {

+ Swift::sleep(1);

+ loop->postEvent(boost::bind(&SimpleEventLoopTest::incrementCounter, this), 0);

+ }

+ loop->stop();

+ }

+

+ void incrementCounter() {

+ counter_++;

+ }

+

+ void incrementCounterAndStop(SimpleEventLoop* loop) {

+ counter_++;

+ loop->stop();

+ }

+

+ int counter_;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(SimpleEventLoopTest);