src/eventloop-integration.cpp

   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 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <dbus-c++/eventloop-integration.h>
  29 #include <dbus-c++/debug.h>
  30
  31 #include <sys/poll.h>
  32
  33 #include <dbus/dbus.h>
  34
  35 DBus::DefaultDispatcher DBus::DefaultDispatcher::instance;
  36
  37 using namespace DBus;
  38
  39 DefaultTimeout::DefaultTimeout(Timeout::Internal *ti, DefaultDispatcher *bd)
  40 : Timeout(ti), SimpleTimeout(Timeout::interval(), true, bd)
  41 {
  42         SimpleTimeout::enabled(Timeout::enabled());
  43 }
  44
  45 void DefaultTimeout::toggle()
  46 {
  47         debug_log("timeout %p toggled (%s)", this, Timeout::enabled() ? "on":"off");
  48
  49         SimpleTimeout::enabled(Timeout::enabled());
  50 }
  51
  52 DefaultWatch::DefaultWatch(Watch::Internal *wi, DefaultDispatcher *bd)
  53 : Watch(wi), SimpleWatch(Watch::descriptor(), 0, bd)
  54 {
  55         int flags = POLLHUP | POLLERR;
  56
  57         if (Watch::flags() & DBUS_WATCH_READABLE)
  58                 flags |= POLLIN;
  59         if (Watch::flags() & DBUS_WATCH_WRITABLE)
  60                 flags |= POLLOUT;
  61
  62         SimpleWatch::flags(flags);
  63         SimpleWatch::enabled(Watch::enabled());
  64 }
  65
  66 void DefaultWatch::toggle()
  67 {
  68         debug_log("watch %p toggled (%s)", this, Watch::enabled() ? "on":"off");
  69
  70         SimpleWatch::enabled(Watch::enabled());
  71 }
  72
  73 void DefaultDispatcher::enter()
  74 {
  75         debug_log("entering dispatcher %p", this);
  76
  77         start_iteration();
  78
  79         while (_running)
  80         {
  81                 do_iteration();
  82         }
  83
  84         debug_log("leaving dispatcher %p", this);
  85 }
  86
  87 void DefaultDispatcher::leave()
  88 {
  89         _running = false;
  90 }
  91
  92 void DefaultDispatcher::start_iteration()
  93 {
  94    _running = true;
  95 }
  96
  97 void DefaultDispatcher::do_iteration()
  98 {
  99         dispatch_pending();
 100         dispatch();
 101 }
 102
 103 Timeout *DefaultDispatcher::add_timeout(Timeout::Internal *ti)
 104 {
 105         DefaultTimeout *bt = new DefaultTimeout(ti, this);
 106
 107         bt->expired = new CallbackNoReturn<DefaultDispatcher, SimpleTimeout &>(this, &DefaultDispatcher::timeout_expired);
 108         bt->data(bt);
 109
 110         debug_log("added timeout %p (%s) interval=%d",
 111                 bt, ((Timeout *)bt)->enabled() ? "on":"off", ((Timeout *)bt)->interval());
 112
 113         return bt;
 114 }
 115
 116 void DefaultDispatcher::rem_timeout(Timeout *t)
 117 {
 118         delete t;
 119
 120         debug_log("removed timeout %p", t);
 121 }
 122
 123 Watch *DefaultDispatcher::add_watch(Watch::Internal *wi)
 124 {
 125         DefaultWatch *bw = new DefaultWatch(wi, this);
 126
 127         bw->ready = new CallbackNoReturn<DefaultDispatcher, SimpleWatch &>(this, &DefaultDispatcher::watch_ready);
 128         bw->data(bw);
 129
 130         debug_log("added watch %p (%s) fd=%d flags=%d",
 131                 bw, ((Watch *)bw)->enabled() ? "on":"off", ((Watch *)bw)->descriptor(), ((Watch *)bw)->flags());
 132
 133         return bw;
 134 }
 135
 136 void DefaultDispatcher::rem_watch(Watch *w)
 137 {
 138         delete w;
 139
 140         debug_log("removed watch %p", w);
 141 }
 142
 143 void DefaultDispatcher::timeout_expired(SimpleTimeout &et)
 144 {
 145         debug_log("timeout %p expired", &et);
 146
 147         DefaultTimeout *timeout = reinterpret_cast<DefaultTimeout *>(et.data());
 148
 149         timeout->handle();
 150 }
 151
 152 void DefaultDispatcher::watch_ready(SimpleWatch &ew)
 153 {
 154         DefaultWatch *watch = reinterpret_cast<DefaultWatch *>(ew.data());
 155
 156         debug_log("watch %p ready, flags=%d state=%d",
 157                 watch, ((Watch *)watch)->flags(), watch->state()
 158         );
 159
 160         int flags = 0;
 161
 162         if (watch->state() & POLLIN)
 163                 flags |= DBUS_WATCH_READABLE;
 164         if (watch->state() & POLLOUT)
 165                 flags |= DBUS_WATCH_WRITABLE;
 166         if (watch->state() & POLLHUP)
 167                 flags |= DBUS_WATCH_HANGUP;
 168         if (watch->state() & POLLERR)
 169                 flags |= DBUS_WATCH_ERROR;
 170
 171         watch->handle(flags);
 172 }
 173