include/dbus-c++/dispatcher.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_DISPATCHER_H
  26 #define __DBUSXX_DISPATCHER_H
  27
  28 #include "api.h"
  29 #include "connection.h"
  30 #include "eventloop.h"
  31
  32 namespace DBus {
  33
  34 class DBUSXXAPI Timeout
  35 {
  36 public:
  37
  38         class Internal;
  39
  40         Timeout(Internal *i);
  41
  42         virtual ~Timeout(){}
  43
  44         int interval() const;
  45
  46         bool enabled() const;
  47
  48         bool handle();
  49
  50         virtual void toggle() = 0;
  51
  52 private:
  53
  54         DBUSXXAPILOCAL Timeout(const Timeout &);
  55
  56 private:
  57
  58         Internal *_int;
  59 };
  60
  61 class DBUSXXAPI Watch
  62 {
  63 public:
  64
  65         class Internal;
  66
  67         Watch(Internal *i);
  68
  69         virtual ~Watch(){}
  70
  71         int descriptor() const;
  72
  73         int flags() const;
  74
  75         bool enabled() const;
  76
  77         bool handle(int flags);
  78
  79         virtual void toggle() = 0;
  80
  81 private:
  82
  83         DBUSXXAPILOCAL Watch(const Watch &);
  84
  85 private:
  86
  87         Internal *_int;
  88 };
  89
  90 class DBUSXXAPI Dispatcher : public Synchronized
  91 {
  92 public:
  93    Dispatcher();
  94         virtual ~Dispatcher();
  95
  96         void queue_connection(Connection::Private *);
  97
  98         void dispatch_pending();
  99         bool has_something_to_dispatch();
 100
 101         virtual void enter() = 0;
 102
 103         virtual void leave() = 0;
 104
 105         virtual Timeout *add_timeout(Timeout::Internal *) = 0;
 106
 107         virtual void rem_timeout(Timeout *) = 0;
 108
 109         virtual Watch *add_watch(Watch::Internal *) = 0;
 110
 111         virtual void rem_watch(Watch *) = 0;
 112
 113         struct Private;
 114
 115 private:
 116
 117         Connection::PrivatePList  _pending_queue;
 118 };
 119
 120 /* classes for multithreading support
 121 */
 122
 123 class DBUSXXAPI Mutex
 124 {
 125 public:
 126
 127         virtual ~Mutex() {}
 128
 129         virtual void lock() = 0;
 130
 131         virtual void unlock() = 0;
 132
 133         struct Internal;
 134
 135 protected:
 136
 137         Internal *_int;
 138 };
 139
 140 class DBUSXXAPI CondVar
 141 {
 142 public:
 143
 144         virtual ~CondVar() {}
 145
 146         virtual void wait(Mutex *) = 0;
 147
 148         virtual bool wait_timeout(Mutex *, int timeout) = 0;
 149
 150         virtual void wake_one() = 0;
 151
 152         virtual void wake_all() = 0;
 153
 154         struct Internal;
 155
 156 protected:
 157
 158         Internal *_int;
 159 };
 160
 161 typedef Mutex *(*MutexNewFn)();
 162 typedef void (*MutexUnlockFn)(Mutex *mx);
 163
 164 #ifndef DBUS_HAS_RECURSIVE_MUTEX
 165 typedef bool (*MutexFreeFn)(Mutex *mx);
 166 typedef bool (*MutexLockFn)(Mutex *mx);
 167 #else
 168 typedef void (*MutexFreeFn)(Mutex *mx);
 169 typedef void (*MutexLockFn)(Mutex *mx);
 170 #endif//DBUS_HAS_RECURSIVE_MUTEX
 171
 172 typedef CondVar *(*CondVarNewFn)();
 173 typedef void (*CondVarFreeFn)(CondVar *cv);
 174 typedef void (*CondVarWaitFn)(CondVar *cv, Mutex *mx);
 175 typedef bool (*CondVarWaitTimeoutFn)(CondVar *cv, Mutex *mx, int timeout);
 176 typedef void (*CondVarWakeOneFn)(CondVar *cv);
 177 typedef void (*CondVarWakeAllFn)(CondVar *cv);
 178
 179 void DBUSXXAPI _init_threading();
 180
 181 void DBUSXXAPI _init_threading(
 182         MutexNewFn, MutexFreeFn, MutexLockFn, MutexUnlockFn,
 183         CondVarNewFn, CondVarFreeFn, CondVarWaitFn, CondVarWaitTimeoutFn, CondVarWakeOneFn, CondVarWakeAllFn
 184 );
 185
 186 template<class Mx, class Cv>
 187 struct Threading
 188 {
 189         static void init()
 190         {
 191                 _init_threading(
 192                         mutex_new, mutex_free, mutex_lock, mutex_unlock,
 193                         condvar_new, condvar_free, condvar_wait, condvar_wait_timeout, condvar_wake_one, condvar_wake_all
 194                 );
 195         }
 196
 197         static Mutex *mutex_new()
 198         {
 199                 return new Mx;
 200         }
 201
 202         static void mutex_free(Mutex *mx)
 203         {
 204                 delete mx;
 205         }
 206
 207         static void mutex_lock(Mutex *mx)
 208         {
 209                 mx->lock();
 210         }
 211
 212         static void mutex_unlock(Mutex *mx)
 213         {
 214                 mx->unlock();
 215         }
 216
 217         static CondVar *condvar_new()
 218         {
 219                 return new Cv;
 220         }
 221
 222         static void condvar_free(CondVar *cv)
 223         {
 224                 delete cv;
 225         }
 226
 227         static void condvar_wait(CondVar *cv, Mutex *mx)
 228         {
 229                 cv->wait(mx);
 230         }
 231
 232         static bool condvar_wait_timeout(CondVar *cv, Mutex *mx, int timeout)
 233         {
 234                 return cv->wait_timeout(mx, timeout);
 235         }
 236
 237         static void condvar_wake_one(CondVar *cv)
 238         {
 239                 cv->wake_one();
 240         }
 241
 242         static void condvar_wake_all(CondVar *cv)
 243         {
 244                 cv->wake_all();
 245         }
 246 };
 247
 248 } /* namespace DBus */
 249
 250 #endif//__DBUSXX_DISPATCHER_H