Changeset e83416


Ignore:
Timestamp:
02/03/12 17:09:38 (3 months ago)
Author:
Micke Prag <micke.prag@…>
Branches:
('master', 'deebf2045e7119c339412580f37a1e653f7d5715')('controller-upgrade', '00f95d22e12d96ef089e0902ef62ae8ce841dc6f')
Children:
ba9c50f6251736f1ee21a6071cb6d80ed267029f
Parents:
12506815144a25f959a1c78776ad82fa8970b5a3
git-author:
Micke Prag <micke.prag@telldus.se>2012-02-03 17:09:38+01:00
git-committer:
Micke Prag <micke.prag@telldus.se>2012-02-03 17:09:38+01:00
Message:

Move class Event and EventHandler into the TelldusCore namespace

Location:
telldus-core
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • telldus-core/common/Event.cpp

    r938187 re83416  
    44 
    55#include <list> 
     6 
     7using namespace TelldusCore; 
    68 
    79EventData::~EventData() { 
    … …  
    2325}; 
    2426 
    25 EventBase::EventBase(EventHandler *handler) { 
     27EventBase::EventBase(TelldusCore::EventHandler *handler) { 
    2628        d = new PrivateData; 
    2729        d->handler = handler; 

  • telldus-core/common/Event.h

    r938187 re83416  
    22#define EVENT_H 
    33 
    4 class EventHandler; 
    54#include "Thread.h" 
    65 
    76#ifdef _WINDOWS 
    8         #include <windows.h> 
    9         #include <memory> 
     7#include <windows.h> 
     8#include <memory> 
    109        typedef HANDLE EVENT_T; 
    1110#else 
    12         #include <tr1/memory> 
     11#include <tr1/memory> 
    1312        typedef void* EVENT_T; 
    1413#endif 
    1514 
    16 class EventData { 
    17 public: 
    18         virtual ~EventData(); 
    19         virtual bool isValid() const; 
    20 }; 
     15namespace TelldusCore { 
     16        class EventHandler; 
    2117 
    22 class EventDataBase : public EventData { 
    23 public: 
    24         virtual bool isValid() const; 
    25 }; 
     18        class EventData { 
     19        public: 
     20                virtual ~EventData(); 
     21                virtual bool isValid() const; 
     22        }; 
    2623 
    27 typedef std::tr1::shared_ptr<EventData> EventDataRef; 
     24        class EventDataBase : public EventData { 
     25        public: 
     26                virtual bool isValid() const; 
     27        }; 
    2828 
    29 class EventBase { 
    30 public: 
    31         virtual ~EventBase(); 
     29        typedef std::tr1::shared_ptr<EventData> EventDataRef; 
    3230 
    33         void popSignal(); 
    34         bool isSignaled(); 
    35         void signal(); 
    36         virtual void signal(EventData *); 
    37         EventDataRef takeSignal(); 
     31        class EventBase { 
     32        public: 
     33                virtual ~EventBase(); 
    3834 
    39 protected: 
    40         EventBase(EventHandler *handler); 
    41         void clearHandler(); 
    42         virtual void clearSignal() = 0; 
    43         EventHandler *handler() const; 
    44         virtual void sendSignal() = 0; 
     35                void popSignal(); 
     36                bool isSignaled(); 
     37                void signal(); 
     38                virtual void signal(EventData *); 
     39                EventDataRef takeSignal(); 
    4540 
    46 private: 
    47         class PrivateData; 
    48         PrivateData *d; 
    49 }; 
     41        protected: 
     42                EventBase(EventHandler *handler); 
     43                void clearHandler(); 
     44                virtual void clearSignal() = 0; 
     45                EventHandler *handler() const; 
     46                virtual void sendSignal() = 0; 
    5047 
    51 class Event : public EventBase { 
    52 public: 
    53         virtual ~Event(); 
     48        private: 
     49                class PrivateData; 
     50                PrivateData *d; 
     51        }; 
    5452 
    55 protected: 
    56         Event(EventHandler *handler); 
    57         EVENT_T retrieveNative(); 
    58         virtual void clearSignal(); 
    59         virtual void sendSignal(); 
     53        class Event : public EventBase { 
     54        public: 
     55                virtual ~Event(); 
    6056 
    61 private: 
    62         class PrivateData; 
    63         PrivateData *d; 
     57        protected: 
     58                Event(EventHandler *handler); 
     59                EVENT_T retrieveNative(); 
     60                virtual void clearSignal(); 
     61                virtual void sendSignal(); 
    6462 
    65 friend class EventHandler; 
    66 }; 
     63        private: 
     64                class PrivateData; 
     65                PrivateData *d; 
    6766 
    68 typedef std::tr1::shared_ptr<Event> EventRef; 
     67                friend class EventHandler; 
     68        }; 
     69 
     70        typedef std::tr1::shared_ptr<Event> EventRef; 
     71} 
    6972 
    7073#endif //EVENT_H 

  • telldus-core/common/EventHandler.h

    r938187 re83416  
    44#include "Event.h" 
    55 
    6 class EventHandler { 
    7 public: 
    8         EventHandler(); 
    9         virtual ~EventHandler(void); 
     6namespace TelldusCore { 
    107 
    11         EventRef addEvent(); 
     8        class EventHandler { 
     9        public: 
     10                EventHandler(); 
     11                virtual ~EventHandler(void); 
    1212 
    13         bool waitForAny(); 
     13                EventRef addEvent(); 
    1414 
    15 protected: 
    16         void signal(Event *event); 
     15                bool waitForAny(); 
    1716 
    18 private: 
    19         class PrivateData; 
    20         PrivateData *d; 
    21         bool listIsSignalled(); 
     17        protected: 
     18                void signal(Event *event); 
    2219 
    23         friend class Event; 
    24 }; 
     20        private: 
     21                class PrivateData; 
     22                PrivateData *d; 
     23                bool listIsSignalled(); 
     24 
     25                friend class Event; 
     26        }; 
     27} 
    2528 
    2629#endif //EVENTHANDLER_H 

  • telldus-core/common/EventHandler_unix.cpp

    r938187 re83416  
    66#include <pthread.h> 
    77#include <stdio.h> 
     8 
     9using namespace TelldusCore; 
    810 
    911class EventHandler::PrivateData { 

  • telldus-core/common/Event_unix.cpp

    r938187 re83416  
    22#include "EventHandler.h" 
    33#include "Thread.h" 
     4 
     5using namespace TelldusCore; 
    46 
    57class Event::PrivateData { 

  • telldus-core/service/ClientCommunicationHandler.cpp

    rb84e8b re83416  
    88public: 
    99        TelldusCore::Socket *clientSocket; 
    10         EventRef event, deviceUpdateEvent; 
     10        TelldusCore::EventRef event, deviceUpdateEvent; 
    1111        bool done; 
    1212        DeviceManager *deviceManager; 
    … …  
    1717} 
    1818 
    19 ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, EventRef event, DeviceManager *deviceManager, EventRef deviceUpdateEvent) 
     19ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent) 
    2020        :Thread() 
    2121{ 

  • telldus-core/service/ClientCommunicationHandler.h

    r41c763 re83416  
    1313public: 
    1414        ClientCommunicationHandler(); 
    15         ClientCommunicationHandler(TelldusCore::Socket *clientSocket, EventRef event, DeviceManager *deviceManager, EventRef deviceUpdateEvent); 
     15        ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent); 
    1616        ~ClientCommunicationHandler(void); 
    1717 

  • telldus-core/service/ConnectionListener.h

    r41c763 re83416  
    1111}; 
    1212 
    13 class ConnectionListenerEventData : public EventDataBase { 
     13class ConnectionListenerEventData : public TelldusCore::EventDataBase { 
    1414public: 
    1515        TelldusCore::Socket *socket; 
    … …  
    1818class ConnectionListener : public TelldusCore::Thread { 
    1919public: 
    20         ConnectionListener(const std::wstring &name, EventRef waitEvent); 
     20        ConnectionListener(const std::wstring &name, TelldusCore::EventRef waitEvent); 
    2121        virtual ~ConnectionListener(void); 
    2222 

  • telldus-core/service/ConnectionListener_unix.cpp

    rbf4589 re83416  
    1515class ConnectionListener::PrivateData { 
    1616public: 
    17         EventRef waitEvent; 
     17        TelldusCore::EventRef waitEvent; 
    1818        std::string name; 
    1919        bool running; 
    2020}; 
    2121 
    22 ConnectionListener::ConnectionListener(const std::wstring &name, EventRef waitEvent) 
     22ConnectionListener::ConnectionListener(const std::wstring &name, TelldusCore::EventRef waitEvent) 
    2323{ 
    2424        d = new PrivateData; 
    … …  
    5757        bind(serverSocket, (struct sockaddr *)&name, size); 
    5858        listen(serverSocket, 5); 
    59          
     59 
    6060        //Change permissions to allow everyone 
    6161        chmod(d->name.c_str(), S_IRWXU | S_IRWXG | S_IRWXO); 
    … …  
    8181                } 
    8282                SOCKET_T clientSocket = accept(serverSocket, NULL, NULL); 
    83                  
     83 
    8484                ConnectionListenerEventData *data = new ConnectionListenerEventData(); 
    8585                data->socket = new TelldusCore::Socket(clientSocket); 

  • telldus-core/service/Controller.cpp

    r0b12c5 re83416  
    55class Controller::PrivateData { 
    66public: 
    7         Event *event; 
     7        TelldusCore::Event *event; 
    88        int id; 
    99}; 
    1010 
    11 Controller::Controller(int id, Event *event){ 
     11Controller::Controller(int id, TelldusCore::Event *event){ 
    1212        d = new PrivateData; 
    1313        d->event = event; 
    … …  
    2929 
    3030        std::list<std::string> msgList = Protocol::decodeData(data); 
    31                  
     31 
    3232        for (std::list<std::string>::iterator msgIt = msgList.begin(); msgIt != msgList.end(); ++msgIt){ 
    3333                this->publishData(*msgIt); 

  • telldus-core/service/Controller.h

    r06ac02 re83416  
    55#include <string> 
    66 
    7 class ControllerEventData : public EventDataBase { 
     7class ControllerEventData : public TelldusCore::EventDataBase { 
    88public: 
    99        std::string msg; 
    … …  
    1212 
    1313class Controller { 
    14 public:  
     14public: 
    1515        virtual ~Controller(); 
    1616 
    … …  
    2020 
    2121protected: 
    22         Controller(int id, Event *event); 
     22        Controller(int id, TelldusCore::Event *event); 
    2323        void publishData(const std::string &data) const; 
    2424        void decodePublishData(const std::string &data) const; 

  • telldus-core/service/ControllerListener.h

    r46bc83 re83416  
    55#include "Event.h" 
    66 
    7 class ControllerChangeEventData : public EventDataBase { 
     7class ControllerChangeEventData : public TelldusCore::EventDataBase { 
    88public: 
    99        int vid, pid; 
    … …  
    1313class ControllerListener : public TelldusCore::Thread { 
    1414public: 
    15         ControllerListener(EventRef event); 
     15        ControllerListener(TelldusCore::EventRef event); 
    1616        virtual ~ControllerListener(); 
    1717 
    1818protected: 
    1919        void run(); 
    20          
    21 private:         
     20 
     21private: 
    2222        class PrivateData; 
    2323        PrivateData *d; 

  • telldus-core/service/ControllerManager.cpp

    rc35be6 re83416  
    1515        int lastControllerId; 
    1616        ControllerMap controllers; 
    17         Event *event; 
     17        TelldusCore::Event *event; 
    1818        TelldusCore::Mutex mutex; 
    1919}; 
    2020 
    21 ControllerManager::ControllerManager(Event *event){ 
     21ControllerManager::ControllerManager(TelldusCore::Event *event){ 
    2222        d = new PrivateData; 
    2323        d->lastControllerId = 0; 

  • telldus-core/service/ControllerManager.h

    r673daf re83416  
    33 
    44class Controller; 
    5 class Event; 
     5namespace TelldusCore { 
     6        class Event; 
     7} 
    68 
    79#include <string> 
    … …  
    911class ControllerManager { 
    1012public: 
    11         ControllerManager(Event *event); 
     13        ControllerManager(TelldusCore::Event *event); 
    1214        ~ControllerManager(void); 
    1315 

  • telldus-core/service/DeviceManager.cpp

    rb84e8b re83416  
    2222         TelldusCore::Mutex lock; 
    2323         ControllerManager *controllerManager; 
    24          EventRef deviceUpdateEvent; 
     24         TelldusCore::EventRef deviceUpdateEvent; 
    2525}; 
    2626 
    27 DeviceManager::DeviceManager(ControllerManager *controllerManager, EventRef deviceUpdateEvent){ 
     27DeviceManager::DeviceManager(ControllerManager *controllerManager, TelldusCore::EventRef deviceUpdateEvent){ 
    2828        d = new PrivateData; 
    2929        d->controllerManager = controllerManager; 

  • telldus-core/service/DeviceManager.h

    r856e23 re83416  
    1313{ 
    1414public: 
    15         DeviceManager(ControllerManager *controllerManager, EventRef deviceUpdateEvent); 
     15        DeviceManager(ControllerManager *controllerManager, TelldusCore::EventRef deviceUpdateEvent); 
    1616        ~DeviceManager(void); 
    1717        int getNumberOfDevices(void); 

  • telldus-core/service/EventUpdateManager.cpp

    r86554b re83416  
    1313class EventUpdateManager::PrivateData { 
    1414public: 
    15         EventHandler eventHandler; 
    16         EventRef stopEvent, updateEvent, clientConnectEvent; 
     15        TelldusCore::EventHandler eventHandler; 
     16        TelldusCore::EventRef stopEvent, updateEvent, clientConnectEvent; 
    1717        SocketList clients; 
    1818        ConnectionListener *eventUpdateClientListener; 
    … …  
    4141} 
    4242 
    43 EventRef EventUpdateManager::retrieveUpdateEvent(){ 
     43TelldusCore::EventRef EventUpdateManager::retrieveUpdateEvent(){ 
    4444 
    4545        return d->updateEvent; 
    … …  
    5555                if(d->clientConnectEvent->isSignaled()){ 
    5656                        //new client added 
    57                         EventDataRef eventData = d->clientConnectEvent->takeSignal(); 
     57                        TelldusCore::EventDataRef eventData = d->clientConnectEvent->takeSignal(); 
    5858                        ConnectionListenerEventData *data = reinterpret_cast<ConnectionListenerEventData*>(eventData.get()); 
    5959                        if(data){ 
    … …  
    6363                else if(d->updateEvent->isSignaled()){ 
    6464                        //device event, signal all clients 
    65                         EventDataRef eventData = d->updateEvent->takeSignal(); 
     65                        TelldusCore::EventDataRef eventData = d->updateEvent->takeSignal(); 
    6666                        EventUpdateData *data = reinterpret_cast<EventUpdateData*>(eventData.get()); 
    6767                        if(data){ 

  • telldus-core/service/EventUpdateManager.h

    r8f2413 re83416  
    55#include "Event.h" 
    66 
    7 class EventUpdateData : public EventDataBase { 
     7class EventUpdateData : public TelldusCore::EventDataBase { 
    88public: 
    99        std::wstring messageType; 
    … …  
    3030        ~EventUpdateManager(void); 
    3131 
    32         EventRef retrieveUpdateEvent(); 
    33         EventRef retrieveClientConnectEvent(); 
     32        TelldusCore::EventRef retrieveUpdateEvent(); 
     33        TelldusCore::EventRef retrieveClientConnectEvent(); 
    3434 
    3535protected: 

  • telldus-core/service/TellStick.h

    r06ac02 re83416  
    2525class TellStick : public Controller, public TelldusCore::Thread { 
    2626public: 
    27         TellStick(int controllerId, Event *event, const TellStickDescriptor &d); 
     27        TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &d); 
    2828        virtual ~TellStick(); 
    2929 

  • telldus-core/service/TellStick_libftdi.cpp

    rd32633 re83416  
    4343}; 
    4444 
    45 TellStick::TellStick(int controllerId, Event *event, const TellStickDescriptor &td ) 
     45TellStick::TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &td ) 
    4646        :Controller(controllerId, event) 
    4747{ 

  • telldus-core/service/TelldusMain.cpp

    r5f1d6e re83416  
    1616class TelldusMain::PrivateData { 
    1717public: 
    18         EventHandler eventHandler; 
    19         EventRef stopEvent, controllerChangeEvent; 
     18        TelldusCore::EventHandler eventHandler; 
     19        TelldusCore::EventRef stopEvent, controllerChangeEvent; 
    2020}; 
    2121 
    … …  
    5858 
    5959void TelldusMain::start(void) { 
    60         EventRef clientEvent = d->eventHandler.addEvent(); 
    61         EventRef dataEvent = d->eventHandler.addEvent(); 
    62         EventRef janitor = d->eventHandler.addEvent(); //Used for regular cleanups 
     60        TelldusCore::EventRef clientEvent = d->eventHandler.addEvent(); 
     61        TelldusCore::EventRef dataEvent = d->eventHandler.addEvent(); 
     62        TelldusCore::EventRef janitor = d->eventHandler.addEvent(); //Used for regular cleanups 
    6363        Timer supervisor(janitor); //Tells the janitor to go back to work 
    6464        supervisor.setInterval(60); //Once every minute 
    … …  
    6767        ControllerManager controllerManager(dataEvent.get()); 
    6868        EventUpdateManager eventUpdateManager; 
    69         EventRef deviceUpdateEvent = eventUpdateManager.retrieveUpdateEvent(); 
     69        TelldusCore::EventRef deviceUpdateEvent = eventUpdateManager.retrieveUpdateEvent(); 
    7070        eventUpdateManager.start(); 
    7171        DeviceManager deviceManager(&controllerManager, deviceUpdateEvent); 
    … …  
    7575        std::list<ClientCommunicationHandler *> clientCommunicationHandlerList; 
    7676 
    77         EventRef handlerEvent = d->eventHandler.addEvent(); 
     77        TelldusCore::EventRef handlerEvent = d->eventHandler.addEvent(); 
    7878 
    7979#ifdef _MACOSX 
    … …  
    8989                if (clientEvent->isSignaled()) { 
    9090                        //New client connection 
    91                         EventDataRef eventDataRef = clientEvent->takeSignal(); 
     91                        TelldusCore::EventDataRef eventDataRef = clientEvent->takeSignal(); 
    9292                        ConnectionListenerEventData *data = reinterpret_cast<ConnectionListenerEventData*>(eventDataRef.get()); 
    9393                        if (data) { 
    … …  
    9999 
    100100                if (d->controllerChangeEvent->isSignaled()) { 
    101                         EventDataRef eventDataRef = d->controllerChangeEvent->takeSignal(); 
     101                        TelldusCore::EventDataRef eventDataRef = d->controllerChangeEvent->takeSignal(); 
    102102                        ControllerChangeEventData *data = reinterpret_cast<ControllerChangeEventData*>(eventDataRef.get()); 
    103103                        if (data) { 
    … …  
    107107 
    108108                if (dataEvent->isSignaled()) { 
    109                         EventDataRef eventData = dataEvent->takeSignal(); 
     109                        TelldusCore::EventDataRef eventData = dataEvent->takeSignal(); 
    110110                        ControllerEventData *data = reinterpret_cast<ControllerEventData*>(eventData.get()); 
    111111                        if (data) { 

  • telldus-core/service/Timer.cpp

    rfb8e97 re83416  
    1010public: 
    1111        PrivateData() : interval(0), running(false) {} 
    12         EventRef event; 
     12        TelldusCore::EventRef event; 
    1313        int interval; 
    1414        bool running; 
    … …  
    2222}; 
    2323 
    24 Timer::Timer(EventRef event) 
     24Timer::Timer(TelldusCore::EventRef event) 
    2525        :TelldusCore::Thread(), d(new PrivateData) 
    2626{ 

  • telldus-core/service/Timer.h

    r988b44 re83416  
    77class Timer : public TelldusCore::Thread { 
    88public: 
    9         Timer(EventRef event); 
     9        Timer(TelldusCore::EventRef event); 
    1010        virtual ~Timer(); 
    1111 
Note: See TracChangeset for help on using the changeset viewer.