-#pragma once

-

-#include <Cocoa/Cocoa.h>

-

-namespace Swift {

- class Event;

- class CocoaEventLoop;

-}

-

-@interface CocoaEvent : NSObject {

- Swift::Event* event;

- Swift::CocoaEventLoop* eventLoop;

-}

-

-// Takes ownership of event

-- (id) initWithEvent: (Swift::Event*) e eventLoop: (Swift::CocoaEventLoop*) el;

-- (void) process;

-- (void) dealloc;

-

-@end

-#include "Swiften/EventLoop/Cocoa/CocoaEvent.h"

-#include "Swiften/EventLoop/Event.h"

-#include "Swiften/EventLoop/Cocoa/CocoaEventLoop.h"

-

-@implementation CocoaEvent

-

-- (id) initWithEvent: (Swift::Event*) e eventLoop: (Swift::CocoaEventLoop*) el {

- self = [super init];

- if (self != nil) {

- event = e;

- eventLoop = el;

- }

- return self;

-}

-

-- (void) process {

- eventLoop->handleEvent(*event);

-}

-

-- (void) dealloc {

- delete event;

- [super dealloc];

-}

-

-@end

-#pragma once

-

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

-

-namespace Swift {

- class CocoaEventLoop : public EventLoop {

- public:

- CocoaEventLoop();

-

- virtual void post(const Event& event);

-

- using EventLoop::handleEvent;

- };

-}

-#include "Swiften/EventLoop/Cocoa/CocoaEventLoop.h"

-#include "Swiften/EventLoop/Cocoa/CocoaEvent.h"

-

-#pragma GCC diagnostic ignored "-Wold-style-cast"

-

-namespace Swift {

-

-CocoaEventLoop::CocoaEventLoop() {

-}

-

-void CocoaEventLoop::post(const Event& event) {

- Event* eventCopy = new Event(event);

- CocoaEvent* cocoaEvent = [[CocoaEvent alloc] initWithEvent: eventCopy eventLoop: this];

- [cocoaEvent

- performSelectorOnMainThread:@selector(process)

- withObject: nil

- waitUntilDone: NO];

- [cocoaEvent release];

-}

-

-}

-#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

-#pragma once

-

-#include <deque>

-#include <iostream>

-#include <boost/function.hpp>

-

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

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

-

-namespace Swift {

- class DummyEventLoop : public EventLoop {

- public:

- DummyEventLoop() {

- }

-

- ~DummyEventLoop() {

- if (!events_.empty()) {

- std::cerr << "DummyEventLoop: Unhandled events at destruction time" << std::endl;

- }

- events_.clear();

- }

-

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

- };

-}

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/function.hpp>

-

-#include "Swiften/EventLoop/EventOwner.h"

-

-namespace Swift {

- struct Event {

- Event(boost::shared_ptr<EventOwner> owner, const boost::function<void()>& callback) :

- owner(owner), callback(callback) {

- }

-

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

- return o.id == id;

- }

-

- unsigned int id;

- boost::shared_ptr<EventOwner> owner;

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

- };

-}

-#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, boost::shared_ptr<EventOwner> 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(boost::shared_ptr<EventOwner> owner) {

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

- events_.remove_if(HasOwner(owner));

-}

-

-}

-#pragma once

-

-#include <boost/function.hpp>

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

-#include <list>

-

-#include "Swiften/EventLoop/Event.h"

-

-namespace Swift {

- class EventOwner;

- class EventLoop {

- public:

- EventLoop();

- virtual ~EventLoop();

-

- void postEvent(boost::function<void ()> event, boost::shared_ptr<EventOwner> owner = boost::shared_ptr<EventOwner>());

- void removeEventsFromOwner(boost::shared_ptr<EventOwner> owner);

-

- protected:

- /**

- * 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(boost::shared_ptr<EventOwner> owner) : owner(owner) {}

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

- boost::shared_ptr<EventOwner> owner;

- };

- boost::mutex eventsMutex_;

- unsigned int nextEventID_;

- std::list<Event> events_;

- };

-}

-#include "Swiften/EventLoop/EventOwner.h"

-

-namespace Swift {

-

-EventOwner::~EventOwner() {

-}

-

-}

-#pragma once

-

-namespace Swift {

- class EventOwner {

- public:

- virtual ~EventOwner();

- };

-}

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

-

-#include <iostream>

-#include <typeinfo>

-

-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, boost::shared_ptr<EventOwner> owner) {

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

-}

-

-void MainEventLoop::removeEventsFromOwner(boost::shared_ptr<EventOwner> 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 EventOwner;

-

- 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, boost::shared_ptr<EventOwner> owner = boost::shared_ptr<EventOwner>());

-

- static void removeEventsFromOwner(boost::shared_ptr<EventOwner> 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

-#pragma once

-

-#include <QObject>

-#include <QEvent>

-#include <QCoreApplication>

-

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

-

-class QtEventLoop : public QObject, public Swift::EventLoop {

- public:

- QtEventLoop() {}

-

- virtual void post(const Swift::Event& event) {

- QCoreApplication::postEvent(this, new Event(event));

- }

-

- virtual bool event(QEvent* qevent) {

- Event* event = dynamic_cast<Event*>(qevent);

- if (event) {

- handleEvent(event->event_);

- //event->deleteLater(); FIXME: Leak?

- return true;

- }

-

- return false;

- }

-

- private:

- struct Event : public QEvent {

- Event(const Swift::Event& event) :

- QEvent(QEvent::User), event_(event) {

- }

-

- Swift::Event event_;

- };

-};

-Import("swiften_env")

-

-sources = [

- "EventLoop.cpp",

- "EventOwner.cpp",

- "MainEventLoop.cpp",

- "SimpleEventLoop.cpp",

- ]

-

-if swiften_env["PLATFORM"] == "darwin" and swiften_env["target"] == "native":

- sources += [

- "Cocoa/CocoaEventLoop.mm",

- "Cocoa/CocoaEvent.mm"

- ]

-

-objects = swiften_env.StaticObject(sources)

-swiften_env.Append(SWIFTEN_OBJECTS = [objects])

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

-

-#include <boost/bind.hpp>

-

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

-

-

-namespace Swift {

-

-void nop() {}

-

-SimpleEventLoop::SimpleEventLoop() : isRunning_(true) {

-}

-

-SimpleEventLoop::~SimpleEventLoop() {

- if (!events_.empty()) {

- std::cerr << "Warning: Pending events in SimpleEventLoop at destruction time" << std::endl;

- }

-}

-

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

-}

-

-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();

-}

-

-

-}

-#pragma once

-

-#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();

- ~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_;

- };

-}

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

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

-#include <boost/thread.hpp>

-#include <boost/bind.hpp>

-

-#include "Swiften/EventLoop/EventOwner.h"

-#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));

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

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

- boost::shared_ptr<MyEventOwner> eventOwner1(new MyEventOwner());

- boost::shared_ptr<MyEventOwner> eventOwner2(new MyEventOwner());

-

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

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

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

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

- testling.removeEventsFromOwner(eventOwner2);

- 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:

- struct MyEventOwner : public EventOwner {};

- void logEvent(int i) {

- events_.push_back(i);

- }

-

- private:

- std::vector<int> events_;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(EventLoopTest);

-#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));

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

- }

- loop->stop();

- }

-

- void incrementCounter() {

- counter_++;

- }

-

- void incrementCounterAndStop(SimpleEventLoop* loop) {

- counter_++;

- loop->stop();

- }

-

- int counter_;

-};

-

-CPPUNIT_TEST_SUITE_REGISTRATION(SimpleEventLoopTest);