jeena/telldus
1
0
Fork 0
Code Issues Pull requests Projects Packages Wiki Activity Actions

Move class Event and EventHandler into the TelldusCore namespace

Browse source
This commit is contained in:
Micke Prag 2012-02-03 17:09:38 +01:00
parent 1250681514
commit e834160492
23 changed files with 125 additions and 111 deletions
Download patch file Download diff file Expand all files Collapse all files

4
telldus-core/common/Event.cpp
View file

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

95
telldus-core/common/Event.h
View file

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

31
telldus-core/common/EventHandler.h
View file

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

2
telldus-core/common/EventHandler_unix.cpp
View file

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

2
telldus-core/common/Event_unix.cpp
View file

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

4
telldus-core/service/ClientCommunicationHandler.cpp
View file

@ -7,7 +7,7 @@
class ClientCommunicationHandler::PrivateData { class ClientCommunicationHandler::PrivateData {
public: public:
TelldusCore::Socket *clientSocket; TelldusCore::Socket *clientSocket;
EventRef event, deviceUpdateEvent; TelldusCore::EventRef event, deviceUpdateEvent;
bool done; bool done;
DeviceManager *deviceManager; 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() :Thread()
{ {
d = new PrivateData; d = new PrivateData;

2
telldus-core/service/ClientCommunicationHandler.h
View file

@ -12,7 +12,7 @@ class ClientCommunicationHandler : public TelldusCore::Thread
{ {
public: public:
ClientCommunicationHandler(); 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); ~ClientCommunicationHandler(void);
bool isDone(); bool isDone();

4
telldus-core/service/ConnectionListener.h
View file

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

8
telldus-core/service/ConnectionListener_unix.cpp
View file

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

8
telldus-core/service/Controller.cpp
View file

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

6
telldus-core/service/Controller.h
View file

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

8
telldus-core/service/ControllerListener.h
View file

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

4
telldus-core/service/ControllerManager.cpp
View file

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

6
telldus-core/service/ControllerManager.h
View file

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

4
telldus-core/service/DeviceManager.cpp
View file

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

2
telldus-core/service/DeviceManager.h
View file

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

10
telldus-core/service/EventUpdateManager.cpp
View file

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

6
telldus-core/service/EventUpdateManager.h
View file

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

2
telldus-core/service/TellStick.h
View file

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

2
telldus-core/service/TellStick_libftdi.cpp
View file

@ -42,7 +42,7 @@ public:
TelldusCore::Mutex mutex; 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) :Controller(controllerId, event)
{ {
d = new PrivateData; d = new PrivateData;

20
telldus-core/service/TelldusMain.cpp
View file

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

4
telldus-core/service/Timer.cpp
View file

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

2
telldus-core/service/Timer.h
View file

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