include/dbus-c++/util.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_UTIL_H
  26 #define __DBUSXX_UTIL_H
  27
  28 #include <pthread.h>
  29 #include <set>
  30
  31 #include "api.h"
  32 #include "debug.h"
  33
  34 #include <list>
  35
  36 namespace DBus {
  37
  38 /*
  39  *   Very simple reference counting
  40  */
  41
  42 class DBUSXXAPI RefCnt
  43 {
  44 public:
  45
  46         RefCnt()
  47         {
  48                 __ref = new int;
  49                 (*__ref) = 1;
  50                 __mtx = new pthread_mutex_t;
  51                 pthread_mutex_init(__mtx, NULL);
  52         }
  53
  54         RefCnt(const RefCnt &rc)
  55         {
  56                 __ref = rc.__ref;
  57                 __mtx = rc.__mtx;
  58                 ref();
  59         }
  60
  61         virtual ~RefCnt()
  62         {
  63                 unref();
  64         }
  65
  66         RefCnt &operator = (const RefCnt &ref)
  67         {
  68                 if (&ref != this)
  69                 {
  70                         ref.ref();
  71                         unref();
  72                         __ref = ref.__ref;
  73                         __mtx = ref.__mtx;
  74                 }
  75                 return *this;
  76         }
  77
  78         bool noref() const
  79         {
  80                 return (*__ref) == 0;
  81         }
  82
  83         bool one() const
  84         {
  85                 return (*__ref) == 1;
  86         }
  87
  88         void lock() const
  89         {
  90                 if ( 0 != __mtx )
  91                 {
  92                         pthread_mutex_lock(__mtx);
  93                 }
  94         }
  95
  96         void unlock() const
  97         {
  98                 if ( 0 != __mtx )
  99                 {
 100                         pthread_mutex_unlock(__mtx);
 101                 }
 102         }
 103
 104 private:
 105
 106         DBUSXXAPILOCAL void ref() const
 107         {
 108                 ++ (*__ref);
 109         }
 110         DBUSXXAPILOCAL void unref()
 111         {
 112                 -- (*__ref);
 113
 114                 if ((*__ref) < 0)
 115                 {
 116                         debug_log("%p: refcount dropped below zero!", __ref);
 117                 }
 118
 119                 if (noref())
 120                 {
 121                         delete __ref;
 122                         __ref = 0;
 123                         pthread_mutex_destroy(__mtx);
 124                         delete __mtx;
 125                         __mtx = 0;
 126                 }
 127         }
 128
 129 private:
 130
 131         int *__ref;
 132         pthread_mutex_t* __mtx;
 133 };
 134
 135 /*
 136  *  Pthreads-based mutual exclusion
 137  */
 138 class Synchronized
 139 {
 140 protected:
 141
 142         struct Guard
 143         {
 144                 Guard(const Synchronized *s) : _s(s)
 145                 {
 146                         _s->lock();
 147                 }
 148                 ~Guard()
 149                 {
 150                         _s->unlock();
 151                 }
 152                 const Synchronized *_s;
 153         };
 154
 155         void lock() const
 156         {
 157                 pthread_mutex_lock(&__mtx);
 158         }
 159
 160         void unlock() const
 161         {
 162                 pthread_mutex_unlock(&__mtx);
 163         }
 164
 165 protected:
 166
 167         Synchronized()
 168         {
 169                 pthread_mutex_init(&__mtx, NULL);
 170         }
 171
 172 public:
 173
 174         ~Synchronized()
 175         {
 176                 pthread_mutex_destroy(&__mtx);
 177         }
 178
 179 private:
 180
 181    // Not supported - unimplemented
 182    Synchronized(const Synchronized& lhs);
 183    Synchronized& operator=(const Synchronized& ref);
 184
 185         mutable pthread_mutex_t __mtx;
 186 };
 187
 188 /*
 189  *   Reference counting pointers (emulate boost::shared_ptr)
 190  */
 191
 192 class RefPtrVoid
 193 {
 194 public:
 195
 196    RefPtrVoid(void *ptr)
 197    : __ptr(ptr)
 198    , __cnt()
 199    {}
 200
 201    RefPtrVoid(const RefPtrVoid& lhs)
 202    : __ptr(0)
 203    , __cnt()
 204    {}
 205
 206         virtual ~RefPtrVoid()
 207         {}
 208
 209         bool operator == (const RefPtrVoid &ref) const
 210         {
 211                 return __ptr == ref.__ptr;
 212         }
 213
 214 protected:
 215
 216         void *__ptr;
 217         RefCnt __cnt;
 218 };
 219
 220 template <class T>
 221 class RefPtrI : public RefPtrVoid               // RefPtr to incomplete type
 222 {
 223 public:
 224
 225         RefPtrI(T *ptr = 0);
 226
 227    RefPtrI(const RefPtrI& lhs);
 228
 229         ~RefPtrI();
 230
 231         RefPtrI &operator = (const RefPtrI &ref)
 232         {
 233       if (this != &ref)
 234       {
 235          __cnt.lock();
 236
 237          // If there is only a single reference (that's us) then ...
 238          if (__cnt.one())
 239          {
 240             delete get();
 241             __ptr = 0;
 242          }
 243
 244          // If "ref" is referencing something other than what we're
 245          // referencing
 246          if ( __ptr != ref.__ptr )
 247          {
 248             ref.__cnt.lock();
 249          }
 250
 251          __ptr = ref.__ptr;
 252          __cnt = ref.__cnt;
 253
 254          // At this point __cnt == __ref.__cnt so unlocking __cnt
 255          // effectively unlocks ref.__cnt as well.
 256          __cnt.unlock();
 257       }
 258       return *this;
 259         }
 260
 261         T &operator *() const
 262         {
 263                 return *get();
 264         }
 265
 266         T *operator ->() const
 267         {
 268                 return get();
 269         }
 270
 271         T *get() const
 272         {
 273                 return static_cast<T *>(__ptr);
 274         }
 275 };
 276
 277 template <class T>
 278 class RefPtr : public RefPtrVoid
 279 {
 280 public:
 281
 282         RefPtr(T *ptr = 0)
 283         : RefPtrVoid(ptr)
 284         {}
 285
 286    RefPtr(const T& lhs)
 287    : RefPtrVoid()
 288    {
 289       *this = lhs;
 290    }
 291
 292         ~RefPtr()
 293         {
 294       __cnt.lock();
 295       if (__cnt.one()) delete get();
 296       __cnt.unlock();
 297         }
 298
 299         RefPtr &operator = (const RefPtr &ref)
 300         {
 301       if (this != &ref)
 302       {
 303          __cnt.lock();
 304
 305          // If there is only a single reference (that's us) then ...
 306          if (__cnt.one())
 307          {
 308             delete get();
 309             __ptr = 0;
 310          }
 311
 312          // If "ref" is referencing something other than what we're
 313          // referencing
 314          if ( __ptr != ref.__ptr )
 315          {
 316             ref.__cnt.lock();
 317          }
 318
 319          __ptr = ref.__ptr;
 320          __cnt = ref.__cnt;
 321
 322          // At this point __cnt == __ref.__cnt so unlocking __cnt
 323          // effectively unlocks ref.__cnt as well.
 324          __cnt.unlock();
 325       }
 326       return *this;
 327         }
 328
 329         T &operator *() const
 330         {
 331                 return *get();
 332         }
 333
 334         T *operator ->() const
 335         {
 336                 return get();
 337         }
 338
 339         T *get() const
 340         {
 341                 return static_cast<T *>(__ptr);
 342         }
 343 };
 344
 345 /*
 346  *   Typed callback template
 347  */
 348
 349 //
 350 // Forward Declarations
 351 //
 352 class CallbackEmitter;
 353 class CallbackTarget;
 354
 355 class CallbackEmitter : protected Synchronized
 356 {
 357 public:
 358    CallbackEmitter();
 359    virtual ~CallbackEmitter();
 360
 361 protected:
 362    void connect(CallbackTarget* tgt);
 363
 364    void disconnect();
 365
 366    bool isConnected() const;
 367
 368 private:
 369    CallbackTarget* target;
 370    friend class CallbackTarget;
 371 };
 372
 373 class CallbackTarget : protected Synchronized
 374 {
 375 public:
 376    CallbackTarget();
 377    virtual ~CallbackTarget();
 378
 379 private:
 380    void disconnect_emitter(CallbackEmitter* cbEmitter);
 381    void connect_emitter(CallbackEmitter* cbEmitter);
 382
 383    typedef std::set<CallbackEmitter*> EmitterCollection;
 384    EmitterCollection emitters;
 385    friend class CallbackEmitter;
 386 };
 387
 388 //
 389 // CallbackTarget Implementation
 390 //
 391 inline CallbackTarget::CallbackTarget()
 392    : Synchronized()
 393    , emitters()
 394 {
 395    debug_log("CallbackTarget(%p)::Constructed");
 396 }
 397
 398 inline CallbackTarget::~CallbackTarget()
 399 {
 400    Guard g(this);
 401    EmitterCollection::const_iterator it;
 402    // Tell all the callback emitters that this target is
 403    // being disconnected.
 404    debug_log("CallbackTarget(%p)::# Emitters to disconnect: %u",
 405             this, emitters.size());
 406
 407    for ( it = emitters.begin(); it != emitters.end(); ++it )
 408    {
 409       debug_log("CallbackTarget(%p)::Disconnect emitter: %p", this, *it);
 410       (*it)->disconnect();
 411    }
 412    emitters.clear();
 413    debug_log("CallbackTarget(%p)::Destroyed", this);
 414 }
 415
 416 inline void CallbackTarget::disconnect_emitter(CallbackEmitter* cbEmitter)
 417 {
 418    Guard g(this);
 419    debug_log("CallbackTarget(%p)::Erasing emitter: %p", this, cbEmitter);
 420    emitters.erase(cbEmitter);
 421 }
 422
 423 inline void CallbackTarget::connect_emitter(CallbackEmitter* cbEmitter)
 424 {
 425    Guard g(this);
 426    debug_log("CallbackTarget(%p)::Inserting emitter: %p", this, cbEmitter);
 427    emitters.insert(cbEmitter);
 428 }
 429
 430 //
 431 // CallbackEmitter Implementation
 432 //
 433
 434 inline CallbackEmitter::CallbackEmitter()
 435    : Synchronized()
 436    , target(0)
 437 {
 438    debug_log("CallbackEmitter(%p)::Constructed", this);
 439 }
 440
 441 inline CallbackEmitter::~CallbackEmitter()
 442 {
 443    Guard g(this);
 444
 445    if ( target )
 446    {
 447       debug_log("CallbackEmitter(%p)::Disconnecting from target: %p", this, target);
 448       target->disconnect_emitter(this);
 449    }
 450
 451    debug_log("CallbackEmitter(%p)::Destroyed", this);
 452 }
 453
 454 inline void CallbackEmitter::connect(CallbackTarget* tgt)
 455 {
 456    Guard g(this);
 457
 458    if ( target && (target != tgt) )
 459    {
 460       // Unregister from the (old) target first
 461       debug_log("CallbackEmitter(%p)::Unregistering emitter from target: %p", this, target);
 462       target->disconnect_emitter(this);
 463    }
 464
 465    target = tgt;
 466    if ( target )
 467    {
 468       debug_log("CallbackEmitter(%p)::Connecting to target: %p", this, target);
 469       target->connect_emitter(this);
 470    }
 471 }
 472
 473 inline void CallbackEmitter::disconnect()
 474 {
 475    Guard g(this);
 476    debug_log("CallbackEmitter(%p)::Disconnecting target: %p", this, target);
 477    target = 0;
 478 }
 479
 480 inline bool CallbackEmitter::isConnected() const
 481 {
 482    return 0 != target;
 483 }
 484
 485
 486 template <class R, class P>
 487 class Callback_Base : public CallbackEmitter
 488 {
 489 public:
 490    Callback_Base() : CallbackEmitter() {}
 491
 492         virtual R call(P param) const = 0;
 493
 494         virtual ~Callback_Base()
 495         {}
 496 };
 497
 498 template <class R, class P>
 499 class Slot
 500 {
 501 public:
 502
 503         Slot &operator = (Callback_Base<R,P>* s)
 504         {
 505                 _cb = s;
 506
 507                 return *this;
 508         }
 509
 510         R operator()(P param) const
 511         {
 512                 /*if (_cb.get())*/ return _cb->call(param);
 513         }
 514
 515         R call(P param) const
 516         {
 517                 /*if (_cb.get())*/ return _cb->call(param);
 518         }
 519
 520         bool empty()
 521         {
 522                 return _cb.get() == 0;
 523         }
 524
 525 private:
 526
 527         RefPtr< Callback_Base<R,P> > _cb;
 528 };
 529
 530
 531 template <class C, class P>
 532 class CallbackNoReturn : public Callback_Base<void,P>
 533 {
 534 public:
 535
 536         typedef void (C::*M)(P);
 537
 538         CallbackNoReturn(C *c, M m)
 539         : _c(c), _m(m)
 540         {
 541            debug_log("CallbackNoReturn(%p)::Ctor - connect to target: %p", this, c);
 542            CallbackEmitter::connect(c);
 543         }
 544
 545         virtual ~CallbackNoReturn()
 546         {
 547            debug_log("CallbackNoReturn(%p)::Destroyed", this);
 548         }
 549
 550    void call(P param) const
 551    {
 552       Synchronized::Guard g(this);
 553
 554       if ( CallbackEmitter::isConnected() )
 555       {
 556          (_c->*_m)(param);
 557       }
 558       return;
 559    }
 560
 561 private:
 562
 563         C *_c; M _m;
 564 };
 565
 566 template <class C, class R, class P>
 567 class Callback : public Callback_Base<R,P>
 568 {
 569 public:
 570
 571    typedef R (C::*M)(P);
 572
 573    Callback(C *c, M m, const R& def)
 574    : _c(c), _m(m), _d(def)
 575    {
 576       debug_log("Callback(%p)::Ctor - connect to target: %p", this, c);
 577       CallbackEmitter::connect(c);
 578    }
 579
 580    virtual ~Callback()
 581    {
 582       debug_log("Callback(%p)::Destroyed", this);
 583    }
 584
 585    R call(P param) const
 586    {
 587       Synchronized::Guard g(this);
 588
 589       if ( CallbackEmitter::isConnected() )
 590       {
 591          return (_c->*_m)(param);
 592       }
 593       return _d;
 594    }
 595
 596 private:
 597
 598    C *_c; M _m; R _d;
 599 };
 600
 601 } /* namespace DBus */
 602
 603 #endif//__DBUSXX_UTIL_H