00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00039 #ifndef BLOCXX_RWLOCKER_HPP_INCLUDE_GUARD_
00040 #define BLOCXX_RWLOCKER_HPP_INCLUDE_GUARD_
00041 #include "blocxx/BLOCXX_config.h"
00042 #include "blocxx/GenericRWLockImpl.hpp"
00043
00044 namespace BLOCXX_NAMESPACE
00045 {
00046
00047 BLOCXX_DECLARE_APIEXCEPTION(RWLocker, BLOCXX_COMMON_API);
00049
00050 class BLOCXX_COMMON_API RWLocker
00051 {
00052 public:
00053 RWLocker();
00054 ~RWLocker();
00055
00059 void getReadLock(const Timeout& timeout);
00060 void getReadLock(UInt32 sTimeout, UInt32 usTimeout=0) BLOCXX_DEPRECATED;
00061
00068 void getWriteLock(const Timeout& timeout);
00069 void getWriteLock(UInt32 sTimeout, UInt32 usTimeout=0) BLOCXX_DEPRECATED;
00070
00074 void releaseReadLock();
00075
00079 void releaseWriteLock();
00080
00081 private:
00082
00083
00084
00085 struct ThreadComparer
00086 {
00087 bool operator()(Thread_t x, Thread_t y) const;
00088 };
00089
00090 GenericRWLockImpl<Thread_t, ThreadComparer> m_impl;
00091
00092
00093 RWLocker(const RWLocker&);
00094 RWLocker& operator=(const RWLocker&);
00095 };
00097 class BLOCXX_COMMON_API ReadLock
00098 {
00099 public:
00100 ReadLock(RWLocker& locker, const Timeout& timeout)
00101 : m_locker(&locker)
00102 , m_released(false)
00103 {
00104 m_locker->getReadLock(timeout);
00105 }
00106 ReadLock(RWLocker& locker, UInt32 sTimeout, UInt32 usTimeout=0) BLOCXX_DEPRECATED;
00107 ~ReadLock()
00108 {
00109 release();
00110 }
00111 void lock(const Timeout& timeout)
00112 {
00113 if (m_released)
00114 {
00115 m_locker->getReadLock(timeout);
00116 m_released = false;
00117 }
00118 }
00119 BLOCXX_DEPRECATED void lock(UInt32 sTimeout, UInt32 usTimeout=0)
00120 {
00121 if (m_released)
00122 {
00123 m_locker->getReadLock(Timeout::relative(sTimeout + static_cast<float>(usTimeout) * 1000000.0));
00124 m_released = false;
00125 }
00126 }
00127 void release()
00128 {
00129 if (!m_released)
00130 {
00131 m_locker->releaseReadLock();
00132 m_released = true;
00133 }
00134 }
00135 private:
00136 RWLocker* m_locker;
00137 bool m_released;
00138
00139 ReadLock(const ReadLock&);
00140 ReadLock& operator=(const ReadLock&);
00141 };
00142
00143 inline
00144 ReadLock::ReadLock(RWLocker& locker, UInt32 sTimeout, UInt32 usTimeout)
00145 : m_locker(&locker)
00146 , m_released(false)
00147 {
00148 m_locker->getReadLock(Timeout::relative(sTimeout + static_cast<float>(usTimeout) * 1000000.0));
00149 }
00151 class BLOCXX_COMMON_API WriteLock
00152 {
00153 public:
00154 WriteLock(RWLocker& locker, const Timeout& timeout)
00155 : m_locker(&locker)
00156 , m_released(false)
00157 {
00158 m_locker->getWriteLock(timeout);
00159 }
00160 WriteLock(RWLocker& locker, UInt32 sTimeout, UInt32 usTimeout=0) BLOCXX_DEPRECATED;
00161 ~WriteLock()
00162 {
00163 release();
00164 }
00165 void lock(const Timeout& timeout)
00166 {
00167 if (m_released)
00168 {
00169 m_locker->getWriteLock(timeout);
00170 m_released = false;
00171 }
00172 }
00173 BLOCXX_DEPRECATED void lock(UInt32 sTimeout, UInt32 usTimeout=0)
00174 {
00175 if (m_released)
00176 {
00177 m_locker->getWriteLock(Timeout::relative(sTimeout + static_cast<float>(usTimeout) * 1000000.0));
00178 m_released = false;
00179 }
00180 }
00181 void release()
00182 {
00183 if (!m_released)
00184 {
00185 m_locker->releaseWriteLock();
00186 m_released = true;
00187 }
00188 }
00189 private:
00190 RWLocker* m_locker;
00191 bool m_released;
00192
00193
00194 WriteLock(const WriteLock&);
00195 WriteLock& operator=(const WriteLock&);
00196 };
00197
00198 inline
00199 WriteLock::WriteLock(RWLocker& locker, UInt32 sTimeout, UInt32 usTimeout)
00200 : m_locker(&locker)
00201 , m_released(false)
00202 {
00203 m_locker->getWriteLock(Timeout::relative(sTimeout + static_cast<float>(usTimeout) * 1000000.0));
00204 }
00205
00206 }
00207
00208 #endif