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