cpp/include/IceUtil/AbstractMutex.h

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #ifndef ICE_UTIL_ABSTRACT_MUTEX_H
  11 #define ICE_UTIL_ABSTRACT_MUTEX_H
  12
  13 #include <IceUtil/Config.h>
  14 #include <IceUtil/Lock.h>
  15
  16 namespace IceUtil
  17 {
  18
  19 class AbstractMutex
  20 {
  21 public:
  22
  23     typedef LockT<AbstractMutex> Lock;
  24     typedef TryLockT<AbstractMutex> TryLock;
  25
  26     virtual ~AbstractMutex()
  27     {};
  28
  29     virtual void lock() const = 0;
  30     virtual void unlock() const = 0;
  31     virtual bool tryLock() const = 0;
  32 };
  33
  34 template <typename T>
  35 class AbstractMutexI : public AbstractMutex, public T
  36 {
  37 public:
  38
  39 #ifndef __BCPLUSPLUS__
  40     typedef LockT<AbstractMutexI> Lock;
  41     typedef TryLockT<AbstractMutexI> TryLock;
  42 #endif
  43
  44     virtual void lock() const
  45     {
  46         T::lock();
  47     }
  48
  49     virtual void unlock() const
  50     {
  51         T::unlock();
  52     }
  53
  54     virtual bool tryLock() const
  55     {
  56         return T::tryLock();
  57     }
  58
  59     virtual ~AbstractMutexI()
  60     {}
  61 };
  62
  63 template <typename T>
  64 class AbstractMutexReadI : public AbstractMutex, public T
  65 {
  66 public:
  67
  68 #ifndef __BCPLUSPLUS__
  69     typedef LockT<AbstractMutexReadI> Lock;
  70     typedef TryLockT<AbstractMutexReadI> TryLock;
  71 #endif
  72
  73     virtual void lock() const
  74     {
  75         T::readLock();
  76     }
  77
  78     virtual void unlock() const
  79     {
  80         T::unlock();
  81     }
  82
  83     virtual bool tryLock() const
  84     {
  85         return T::tryReadLock();
  86     }
  87
  88     virtual ~AbstractMutexReadI()
  89     {}
  90 };
  91
  92 template <typename T>
  93 class AbstractMutexWriteI : public AbstractMutex, public T
  94 {
  95 public:
  96
  97 #ifndef __BCPLUSPLUS__
  98     typedef LockT<AbstractMutexWriteI> Lock;
  99     typedef TryLockT<AbstractMutexWriteI> TryLock;
 100 #endif
 101
 102     virtual void lock() const
 103     {
 104         T::writeLock();
 105     }
 106
 107     virtual void unlock() const
 108     {
 109         T::unlock();
 110     }
 111
 112     virtual bool tryLock() const
 113     {
 114         return T::tryWriteLock();
 115     }
 116
 117     virtual ~AbstractMutexWriteI()
 118     {}
 119 };
 120
 121
 122 }
 123
 124 #endif