src/pendingcall.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++/pendingcall.h>
  29
  30 #include <dbus/dbus.h>
  31
  32 #include "internalerror.h"
  33 #include "pendingcall_p.h"
  34 #include "message_p.h"
  35
  36 using namespace DBus;
  37
  38 PendingCall::Private::Private(DBusPendingCall *dpc, ObjectProxy *p, const PendingCallSlot &s, void* data)
  39 : call(dpc), proxy(p), slot(s), dataslot(-1)
  40 {
  41         if (!dbus_pending_call_allocate_data_slot(&dataslot))
  42         {
  43                 throw ErrorNoMemory("Unable to allocate data slot");
  44         }
  45
  46    if (!dbus_pending_call_set_data(call, dataslot, data, NULL))
  47    {
  48       throw ErrorNoMemory("Unable to initialize data slot");
  49    }
  50
  51         if (!dbus_pending_call_set_notify(call, Private::notify_stub, this, NULL))
  52         {
  53                 throw ErrorNoMemory("Unable to initialize pending call");
  54         }
  55 }
  56
  57 PendingCall::Private::~Private()
  58 {
  59         if (dataslot != -1)
  60         {
  61                 dbus_pending_call_free_data_slot(&dataslot);
  62         }
  63 }
  64
  65 void PendingCall::Private::notify_stub(DBusPendingCall *dpc, void *data)
  66 {
  67         PendingCall::Private *pvt = static_cast<PendingCall::Private *>(data);
  68
  69         pvt->slot(*(pvt->token));
  70
  71         pvt->proxy->_pending.erase(pvt->token);
  72 }
  73
  74 PendingCall::PendingCall()
  75 {}
  76
  77 PendingCall::PendingCall(PendingCall::Private *pvt)
  78 : _pvt(pvt)
  79 {
  80         pvt->token = pvt->proxy->_pending.insert(*this);
  81 }
  82
  83 PendingCall::PendingCall(const PendingCall &c)
  84 : _pvt(c._pvt)
  85 {
  86         if (_pvt.get()) dbus_pending_call_ref(_pvt->call);
  87 }
  88
  89 PendingCall::~PendingCall()
  90 {
  91         if (_pvt.get()) dbus_pending_call_unref(_pvt->call);
  92 }
  93
  94 PendingCall &PendingCall::operator = (const PendingCall &c)
  95 {
  96         if (&c != this)
  97         {
  98                 if (_pvt.get()) dbus_pending_call_unref(_pvt->call);
  99                 _pvt = c._pvt;
 100                 if (_pvt.get()) dbus_pending_call_ref(_pvt->call);
 101         }
 102         return *this;
 103 }
 104
 105 bool PendingCall::operator == (const PendingCall &c) const
 106 {
 107         return _pvt == c._pvt;
 108 }
 109
 110 bool PendingCall::completed() const
 111 {
 112         return dbus_pending_call_get_completed(_pvt->call);
 113 }
 114
 115 void PendingCall::cancel()
 116 {
 117         dbus_pending_call_cancel(_pvt->call);
 118         _pvt->proxy->_pending.erase(_pvt->token);
 119 }
 120
 121 void PendingCall::block()
 122 {
 123         dbus_pending_call_block(_pvt->call);
 124 }
 125
 126 void PendingCall::data(void *p)
 127 {
 128         if (!dbus_pending_call_set_data(_pvt->call, _pvt->dataslot, p, NULL))
 129         {
 130                 throw ErrorNoMemory("Unable to initialize data slot");
 131         }
 132 }
 133
 134 void *PendingCall::data() const
 135 {
 136         return dbus_pending_call_get_data(_pvt->call, _pvt->dataslot);
 137 }
 138
 139 const PendingCallSlot &PendingCall::slot() const
 140 {
 141         return _pvt->slot;
 142 }
 143