Move class Event and EventHandler into the TelldusCore namespace

telldus-core/common/Event.cpp

@@ -4,6 +4,8 @@
 
 #include <list>
 
+using namespace TelldusCore;
+
 EventData::~EventData() {
 }
 
@@ -22,7 +24,7 @@ public:
 	std::list<EventDataRef> eventDataList;
 };
 
-EventBase::EventBase(EventHandler *handler) {
+EventBase::EventBase(TelldusCore::EventHandler *handler) {
 	d = new PrivateData;
 	d->handler = handler;
 }

telldus-core/common/Event.h

@@ -1,70 +1,73 @@
 #ifndef EVENT_H
 #define EVENT_H
 
-class EventHandler;
 #include "Thread.h"
 
 #ifdef _WINDOWS
-	#include <windows.h>
-	#include <memory>
+#include <windows.h>
+#include <memory>
 	typedef HANDLE EVENT_T;
 #else
-	#include <tr1/memory>
+#include <tr1/memory>
 	typedef void* EVENT_T;
 #endif
 
-class EventData {
-public:
-	virtual ~EventData();
-	virtual bool isValid() const;
-};
+namespace TelldusCore {
+	class EventHandler;
 
-class EventDataBase : public EventData {
-public:
-	virtual bool isValid() const;
-};
+	class EventData {
+	public:
+		virtual ~EventData();
+		virtual bool isValid() const;
+	};
 
-typedef std::tr1::shared_ptr<EventData> EventDataRef;
+	class EventDataBase : public EventData {
+	public:
+		virtual bool isValid() const;
+	};
 
-class EventBase {
-public:
-	virtual ~EventBase();
+	typedef std::tr1::shared_ptr<EventData> EventDataRef;
 
-	void popSignal();
-	bool isSignaled();
-	void signal();
-	virtual void signal(EventData *);
-	EventDataRef takeSignal();
+	class EventBase {
+	public:
+		virtual ~EventBase();
 
-protected:
-	EventBase(EventHandler *handler);
-	void clearHandler();
-	virtual void clearSignal() = 0;
-	EventHandler *handler() const;
-	virtual void sendSignal() = 0;
+		void popSignal();
+		bool isSignaled();
+		void signal();
+		virtual void signal(EventData *);
+		EventDataRef takeSignal();
 
-private:
-	class PrivateData;
-	PrivateData *d;
-};
+	protected:
+		EventBase(EventHandler *handler);
+		void clearHandler();
+		virtual void clearSignal() = 0;
+		EventHandler *handler() const;
+		virtual void sendSignal() = 0;
 
-class Event : public EventBase {
-public:
-	virtual ~Event();
+	private:
+		class PrivateData;
+		PrivateData *d;
+	};
 
-protected:
-	Event(EventHandler *handler);
-	EVENT_T retrieveNative();
-	virtual void clearSignal();
-	virtual void sendSignal();
+	class Event : public EventBase {
+	public:
+		virtual ~Event();
 
-private:
-	class PrivateData;
-	PrivateData *d;
+	protected:
+		Event(EventHandler *handler);
+		EVENT_T retrieveNative();
+		virtual void clearSignal();
+		virtual void sendSignal();
 
-friend class EventHandler;
-};
+	private:
+		class PrivateData;
+		PrivateData *d;
 
-typedef std::tr1::shared_ptr<Event> EventRef;
+		friend class EventHandler;
+	};
+
+	typedef std::tr1::shared_ptr<Event> EventRef;
+}
 
 #endif //EVENT_H

telldus-core/common/EventHandler.h

@@ -3,24 +3,27 @@
 
 #include "Event.h"
 
-class EventHandler {
-public:
-	EventHandler();
-	virtual ~EventHandler(void);
+namespace TelldusCore {
 
-	EventRef addEvent();
+	class EventHandler {
+	public:
+		EventHandler();
+		virtual ~EventHandler(void);
 
-	bool waitForAny();
+		EventRef addEvent();
 
-protected:
-	void signal(Event *event);
+		bool waitForAny();
 
-private:
-	class PrivateData;
-	PrivateData *d;
-	bool listIsSignalled();
+	protected:
+		void signal(Event *event);
 
-	friend class Event;
-};
+	private:
+		class PrivateData;
+		PrivateData *d;
+		bool listIsSignalled();
+
+		friend class Event;
+	};
+}
 
 #endif //EVENTHANDLER_H

telldus-core/common/EventHandler_unix.cpp

@@ -6,6 +6,8 @@
 #include <pthread.h>
 #include <stdio.h>
 
+using namespace TelldusCore;
+
 class EventHandler::PrivateData {
 public:
 	pthread_cond_t event;

telldus-core/common/Event_unix.cpp

@@ -2,6 +2,8 @@
 #include "EventHandler.h"
 #include "Thread.h"
 
+using namespace TelldusCore;
+
 class Event::PrivateData {
 public:
 };

telldus-core/service/ClientCommunicationHandler.cpp

@@ -7,7 +7,7 @@
 class ClientCommunicationHandler::PrivateData {
 public:
 	TelldusCore::Socket *clientSocket;
-	EventRef event, deviceUpdateEvent;
+	TelldusCore::EventRef event, deviceUpdateEvent;
 	bool done;
 	DeviceManager *deviceManager;
 };
@@ -16,7 +16,7 @@ ClientCommunicationHandler::ClientCommunicationHandler(){
 
 }
 
-ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, EventRef event, DeviceManager *deviceManager, EventRef deviceUpdateEvent)
+ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent)
 	:Thread()
 {
 	d = new PrivateData;

telldus-core/service/ClientCommunicationHandler.h

@@ -12,7 +12,7 @@ class ClientCommunicationHandler : public TelldusCore::Thread
 {
 public:
 	ClientCommunicationHandler();
-	ClientCommunicationHandler(TelldusCore::Socket *clientSocket, EventRef event, DeviceManager *deviceManager, EventRef deviceUpdateEvent);
+	ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent);
 	~ClientCommunicationHandler(void);
 
 	bool isDone();

telldus-core/service/ConnectionListener.h

@@ -10,14 +10,14 @@ namespace TelldusCore {
 	class Socket;
 };
 
-class ConnectionListenerEventData : public EventDataBase {
+class ConnectionListenerEventData : public TelldusCore::EventDataBase {
 public:
 	TelldusCore::Socket *socket;
 };
 
 class ConnectionListener : public TelldusCore::Thread {
 public:
-	ConnectionListener(const std::wstring &name, EventRef waitEvent);
+	ConnectionListener(const std::wstring &name, TelldusCore::EventRef waitEvent);
 	virtual ~ConnectionListener(void);
 
 protected:

telldus-core/service/ConnectionListener_unix.cpp

@@ -14,12 +14,12 @@
 
 class ConnectionListener::PrivateData {
 public:
-	EventRef waitEvent;
+	TelldusCore::EventRef waitEvent;
 	std::string name;
 	bool running;
 };
 
-ConnectionListener::ConnectionListener(const std::wstring &name, EventRef waitEvent)
+ConnectionListener::ConnectionListener(const std::wstring &name, TelldusCore::EventRef waitEvent)
 {
 	d = new PrivateData;
 	d->waitEvent = waitEvent;
@@ -56,7 +56,7 @@ void ConnectionListener::run(){
 	int size = SUN_LEN(&name);
 	bind(serverSocket, (struct sockaddr *)&name, size);
 	listen(serverSocket, 5);
-	
+
 	//Change permissions to allow everyone
 	chmod(d->name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
 	len = sizeof(struct sockaddr_un);
@@ -80,7 +80,7 @@ void ConnectionListener::run(){
 			continue;
 		}
 		SOCKET_T clientSocket = accept(serverSocket, NULL, NULL);
-		
+
 		ConnectionListenerEventData *data = new ConnectionListenerEventData();
 		data->socket = new TelldusCore::Socket(clientSocket);
 		d->waitEvent->signal(data);

telldus-core/service/Controller.cpp

@@ -4,11 +4,11 @@
 
 class Controller::PrivateData {
 public:
-	Event *event;
+	TelldusCore::Event *event;
 	int id;
 };
 
-Controller::Controller(int id, Event *event){
+Controller::Controller(int id, TelldusCore::Event *event){
 	d = new PrivateData;
 	d->event = event;
 	d->id = id;
@@ -28,8 +28,8 @@ void Controller::publishData(const std::string &msg) const {
 void Controller::decodePublishData(const std::string &data) const {
 
 	std::list<std::string> msgList = Protocol::decodeData(data);
-		
+
 	for (std::list<std::string>::iterator msgIt = msgList.begin(); msgIt != msgList.end(); ++msgIt){
 		this->publishData(*msgIt);
 	}
-}
+}

telldus-core/service/Controller.h

@@ -4,14 +4,14 @@
 #include "Event.h"
 #include <string>
 
-class ControllerEventData : public EventDataBase {
+class ControllerEventData : public TelldusCore::EventDataBase {
 public:
 	std::string msg;
 	int controllerId;
 };
 
 class Controller {
-public: 
+public:
 	virtual ~Controller();
 
 	virtual int firmwareVersion() = 0;
@@ -19,7 +19,7 @@ public:
 	virtual int reset() = 0;
 
 protected:
-	Controller(int id, Event *event);
+	Controller(int id, TelldusCore::Event *event);
 	void publishData(const std::string &data) const;
 	void decodePublishData(const std::string &data) const;
 

telldus-core/service/ControllerListener.h

@@ -4,7 +4,7 @@
 #include "Thread.h"
 #include "Event.h"
 
-class ControllerChangeEventData : public EventDataBase {
+class ControllerChangeEventData : public TelldusCore::EventDataBase {
 public:
 	int vid, pid;
 	bool inserted;
@@ -12,13 +12,13 @@ public:
 
 class ControllerListener : public TelldusCore::Thread {
 public:
-	ControllerListener(EventRef event);
+	ControllerListener(TelldusCore::EventRef event);
 	virtual ~ControllerListener();
 
 protected:
 	void run();
-	
-private:	
+
+private:
 	class PrivateData;
 	PrivateData *d;
 };

telldus-core/service/ControllerManager.cpp

@@ -14,11 +14,11 @@ class ControllerManager::PrivateData {
 public:
 	int lastControllerId;
 	ControllerMap controllers;
-	Event *event;
+	TelldusCore::Event *event;
 	TelldusCore::Mutex mutex;
 };
 
-ControllerManager::ControllerManager(Event *event){
+ControllerManager::ControllerManager(TelldusCore::Event *event){
 	d = new PrivateData;
 	d->lastControllerId = 0;
 	d->event = event;

telldus-core/service/ControllerManager.h

@@ -2,13 +2,15 @@
 #define CONTROLLERMANAGER_H
 
 class Controller;
-class Event;
+namespace TelldusCore {
+	class Event;
+}
 
 #include <string>
 
 class ControllerManager {
 public:
-	ControllerManager(Event *event);
+	ControllerManager(TelldusCore::Event *event);
 	~ControllerManager(void);
 
 	void deviceInsertedOrRemoved(int vid, int pid, const std::string &serial, bool inserted);

telldus-core/service/DeviceManager.cpp

@@ -21,10 +21,10 @@ public:
 	 Settings set;
 	 TelldusCore::Mutex lock;
 	 ControllerManager *controllerManager;
-	 EventRef deviceUpdateEvent;
+	 TelldusCore::EventRef deviceUpdateEvent;
 };
 
-DeviceManager::DeviceManager(ControllerManager *controllerManager, EventRef deviceUpdateEvent){
+DeviceManager::DeviceManager(ControllerManager *controllerManager, TelldusCore::EventRef deviceUpdateEvent){
 	d = new PrivateData;
 	d->controllerManager = controllerManager;
 	d->deviceUpdateEvent = deviceUpdateEvent;

telldus-core/service/DeviceManager.h

@@ -12,7 +12,7 @@ class Sensor;
 class DeviceManager
 {
 public:
-	DeviceManager(ControllerManager *controllerManager, EventRef deviceUpdateEvent);
+	DeviceManager(ControllerManager *controllerManager, TelldusCore::EventRef deviceUpdateEvent);
 	~DeviceManager(void);
 	int getNumberOfDevices(void);
 	int addDevice();

telldus-core/service/EventUpdateManager.cpp

@@ -12,8 +12,8 @@ typedef std::list<TelldusCore::Socket *> SocketList;
 
 class EventUpdateManager::PrivateData {
 public:
-	EventHandler eventHandler;
-	EventRef stopEvent, updateEvent, clientConnectEvent;
+	TelldusCore::EventHandler eventHandler;
+	TelldusCore::EventRef stopEvent, updateEvent, clientConnectEvent;
 	SocketList clients;
 	ConnectionListener *eventUpdateClientListener;
 };
@@ -40,7 +40,7 @@ EventUpdateManager::~EventUpdateManager(void) {
 	delete d;
 }
 
-EventRef EventUpdateManager::retrieveUpdateEvent(){
+TelldusCore::EventRef EventUpdateManager::retrieveUpdateEvent(){
 
 	return d->updateEvent;
 }
@@ -54,7 +54,7 @@ void EventUpdateManager::run(){
 
 		if(d->clientConnectEvent->isSignaled()){
 			//new client added
-			EventDataRef eventData = d->clientConnectEvent->takeSignal();
+			TelldusCore::EventDataRef eventData = d->clientConnectEvent->takeSignal();
 			ConnectionListenerEventData *data = reinterpret_cast<ConnectionListenerEventData*>(eventData.get());
 			if(data){
 				d->clients.push_back(data->socket);
@@ -62,7 +62,7 @@ void EventUpdateManager::run(){
 		}
 		else if(d->updateEvent->isSignaled()){
 			//device event, signal all clients
-			EventDataRef eventData = d->updateEvent->takeSignal();
+			TelldusCore::EventDataRef eventData = d->updateEvent->takeSignal();
 			EventUpdateData *data = reinterpret_cast<EventUpdateData*>(eventData.get());
 			if(data){
 				sendMessageToClients(data);

telldus-core/service/EventUpdateManager.h

@@ -4,7 +4,7 @@
 #include "Thread.h"
 #include "Event.h"
 
-class EventUpdateData : public EventDataBase {
+class EventUpdateData : public TelldusCore::EventDataBase {
 public:
 	std::wstring messageType;
 	int controllerId;
@@ -29,8 +29,8 @@ public:
 	EventUpdateManager(void);
 	~EventUpdateManager(void);
 
-	EventRef retrieveUpdateEvent();
-	EventRef retrieveClientConnectEvent();
+	TelldusCore::EventRef retrieveUpdateEvent();
+	TelldusCore::EventRef retrieveClientConnectEvent();
 
 protected:
 	void run();

telldus-core/service/TellStick.h

@@ -24,7 +24,7 @@ public:
 
 class TellStick : public Controller, public TelldusCore::Thread {
 public:
-	TellStick(int controllerId, Event *event, const TellStickDescriptor &d);
+	TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &d);
 	virtual ~TellStick();
 
 	virtual int firmwareVersion();

telldus-core/service/TellStick_libftdi.cpp

@@ -42,7 +42,7 @@ public:
 	TelldusCore::Mutex mutex;
 };
 
-TellStick::TellStick(int controllerId, Event *event, const TellStickDescriptor &td )
+TellStick::TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &td )
 	:Controller(controllerId, event)
 {
 	d = new PrivateData;

telldus-core/service/TelldusMain.cpp

@@ -15,8 +15,8 @@
 
 class TelldusMain::PrivateData {
 public:
-	EventHandler eventHandler;
-	EventRef stopEvent, controllerChangeEvent;
+	TelldusCore::EventHandler eventHandler;
+	TelldusCore::EventRef stopEvent, controllerChangeEvent;
 };
 
 TelldusMain::TelldusMain(void)
@@ -57,16 +57,16 @@ void TelldusMain::suspend() {
 }
 
 void TelldusMain::start(void) {
-	EventRef clientEvent = d->eventHandler.addEvent();
-	EventRef dataEvent = d->eventHandler.addEvent();
-	EventRef janitor = d->eventHandler.addEvent(); //Used for regular cleanups
+	TelldusCore::EventRef clientEvent = d->eventHandler.addEvent();
+	TelldusCore::EventRef dataEvent = d->eventHandler.addEvent();
+	TelldusCore::EventRef janitor = d->eventHandler.addEvent(); //Used for regular cleanups
 	Timer supervisor(janitor); //Tells the janitor to go back to work
 	supervisor.setInterval(60); //Once every minute
 	supervisor.start();
 
 	ControllerManager controllerManager(dataEvent.get());
 	EventUpdateManager eventUpdateManager;
-	EventRef deviceUpdateEvent = eventUpdateManager.retrieveUpdateEvent();
+	TelldusCore::EventRef deviceUpdateEvent = eventUpdateManager.retrieveUpdateEvent();
 	eventUpdateManager.start();
 	DeviceManager deviceManager(&controllerManager, deviceUpdateEvent);
 
@@ -74,7 +74,7 @@ void TelldusMain::start(void) {
 
 	std::list<ClientCommunicationHandler *> clientCommunicationHandlerList;
 
-	EventRef handlerEvent = d->eventHandler.addEvent();
+	TelldusCore::EventRef handlerEvent = d->eventHandler.addEvent();
 
 #ifdef _MACOSX
 	//This is only needed on OS X
@@ -88,7 +88,7 @@ void TelldusMain::start(void) {
 		}
 		if (clientEvent->isSignaled()) {
 			//New client connection
-			EventDataRef eventDataRef = clientEvent->takeSignal();
+			TelldusCore::EventDataRef eventDataRef = clientEvent->takeSignal();
 			ConnectionListenerEventData *data = reinterpret_cast<ConnectionListenerEventData*>(eventDataRef.get());
 			if (data) {
 				ClientCommunicationHandler *clientCommunication = new ClientCommunicationHandler(data->socket, handlerEvent, &deviceManager, deviceUpdateEvent);
@@ -98,7 +98,7 @@ void TelldusMain::start(void) {
 		}
 
 		if (d->controllerChangeEvent->isSignaled()) {
-			EventDataRef eventDataRef = d->controllerChangeEvent->takeSignal();
+			TelldusCore::EventDataRef eventDataRef = d->controllerChangeEvent->takeSignal();
 			ControllerChangeEventData *data = reinterpret_cast<ControllerChangeEventData*>(eventDataRef.get());
 			if (data) {
 				controllerManager.deviceInsertedOrRemoved(data->vid, data->pid, "", data->inserted);
@@ -106,7 +106,7 @@ void TelldusMain::start(void) {
 		}
 
 		if (dataEvent->isSignaled()) {
-			EventDataRef eventData = dataEvent->takeSignal();
+			TelldusCore::EventDataRef eventData = dataEvent->takeSignal();
 			ControllerEventData *data = reinterpret_cast<ControllerEventData*>(eventData.get());
 			if (data) {
 				deviceManager.handleControllerMessage(*data);

telldus-core/service/Timer.cpp

@@ -9,7 +9,7 @@
 class Timer::PrivateData {
 public:
 	PrivateData() : interval(0), running(false) {}
-	EventRef event;
+	TelldusCore::EventRef event;
 	int interval;
 	bool running;
 #ifdef _WINDOWS
@@ -21,7 +21,7 @@ public:
 #endif
 };
 
-Timer::Timer(EventRef event)
+Timer::Timer(TelldusCore::EventRef event)
 	:TelldusCore::Thread(), d(new PrivateData)
 {
 	d->event = event;

telldus-core/service/Timer.h

@@ -6,7 +6,7 @@
 
 class Timer : public TelldusCore::Thread {
 public:
-	Timer(EventRef event);
+	Timer(TelldusCore::EventRef event);
 	virtual ~Timer();
 
 	void setInterval(int sec);