include/dbus-c++/eventloop.h

   1 /*
   2  *
   3  *  D-Bus++ - C++ bindings for D-Bus
   4  *
   5  *  Copyright (C) 2005-2009  Paolo Durante <shackan@gmail.com>
   6  *
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24
  25 #ifndef __DBUSXX_EVENTLOOP_H
  26 #define __DBUSXX_EVENTLOOP_H
  27
  28 #include <pthread.h>
  29 #include <list>
  30 #include <stdint.h>
  31
  32 #include "api.h"
  33 #include "util.h"
  34
  35 namespace DBus {
  36
  37 /*
  38  * these Simple *classes implement a very simple event loop which
  39  * is used here as the default main loop, if you want to hook
  40  * a different one use the Bus *classes in eventloop-integration.h
  41  * or the Glib::Bus *classes as a reference
  42  */
  43
  44 class SimpleMainLoop;
  45
  46 class DBUSXXAPI SimpleTimeout
  47 {
  48 public:
  49
  50         SimpleTimeout(int interval, bool repeat, SimpleMainLoop *);
  51
  52         virtual ~SimpleTimeout();
  53
  54         bool enabled(){ return _enabled; }
  55         void enabled(bool e){ _enabled = e; }
  56
  57         int interval(){ return _interval; }
  58         void interval(int i){ _interval = i; }
  59
  60         bool repeat(){ return _repeat; }
  61         void repeat(bool r){ _repeat = r; }
  62
  63         void *data(){ return _data; }
  64         void data(void *d){ _data = d; }
  65
  66         Slot<void, SimpleTimeout &> expired;
  67
  68 private:
  69
  70         bool _enabled;
  71
  72         int _interval;
  73         bool _repeat;
  74
  75         double _expiration;
  76
  77         void *_data;
  78
  79         SimpleMainLoop *_disp;
  80
  81 friend class SimpleMainLoop;
  82 };
  83
  84 typedef std::list< SimpleTimeout *> SimpleTimeouts;
  85
  86 class DBUSXXAPI SimpleWatch
  87 {
  88 public:
  89
  90         SimpleWatch(int fd, int flags, SimpleMainLoop *);
  91
  92         virtual ~SimpleWatch();
  93
  94         bool enabled(){ return _enabled; }
  95         void enabled(bool e){ _enabled = e; }
  96
  97         int descriptor(){ return _fd; }
  98
  99         int flags(){ return _flags; }
 100         void flags(int f){ _flags = f; }
 101
 102         int state(){ return _state; }
 103
 104         void *data(){ return _data; }
 105         void data(void *d){ _data = d; }
 106
 107         Slot<void, SimpleWatch &> ready;
 108
 109 private:
 110
 111         bool _enabled;
 112
 113         int _fd;
 114         int _flags;
 115         int _state;
 116
 117         void *_data;
 118
 119         SimpleMainLoop *_disp;
 120
 121 friend class SimpleMainLoop;
 122 };
 123
 124 typedef std::list< SimpleWatch *> SimpleWatches;
 125
 126 class DBUSXXAPI SimpleMutex
 127 {
 128 public:
 129
 130         SimpleMutex();
 131
 132         ~SimpleMutex();
 133
 134         void lock();
 135
 136         void unlock();
 137
 138 private:
 139
 140         pthread_mutex_t _mutex;
 141 };
 142
 143 class DBUSXXAPI SimpleMainLoop
 144 {
 145 public:
 146
 147         SimpleMainLoop(int32_t pollTimeout);
 148
 149         virtual ~SimpleMainLoop();
 150
 151         virtual void dispatch();
 152
 153 private:
 154
 155         SimpleMutex _mutex_t;
 156         SimpleTimeouts _timeouts;
 157
 158         SimpleMutex _mutex_w;
 159         SimpleWatches _watches;
 160         int32_t _pollTimeout;
 161
 162 friend class SimpleTimeout;
 163 friend class SimpleWatch;
 164 };
 165
 166 } /* namespace DBus */
 167
 168 #endif//__DBUSXX_EVENTLOOP_H