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 #ifndef __CORE_UTILS_LOCK_SET_H_
00026 #define __CORE_UTILS_LOCK_SET_H_
00027
00028 #include <core/threading/mutex.h>
00029 #include <core/utils/refptr.h>
00030 #include <set>
00031
00032 namespace fawkes {
00033
00034 template <typename KeyType,
00035 typename LessKey = std::less<KeyType> >
00036 class LockSet : public std::set<KeyType, LessKey>
00037 {
00038 public:
00039 LockSet();
00040 LockSet(const LockSet<KeyType, LessKey> &lm);
00041 virtual ~LockSet();
00042
00043 void lock() const;
00044 bool try_lock() const;
00045 void unlock() const;
00046 RefPtr<Mutex> mutex() const;
00047
00048
00049 typedef typename std::set<KeyType, LessKey>::iterator iterator;
00050
00051 std::pair<iterator, bool> insert_locked(const KeyType &key);
00052 void erase_locked(const KeyType &key);
00053
00054 LockSet<KeyType, LessKey> & operator=(const LockSet<KeyType, LessKey> &ll);
00055 LockSet<KeyType, LessKey> & operator=(const std::set<KeyType, LessKey> &l);
00056
00057 private:
00058 mutable RefPtr<Mutex> __mutex;
00059
00060 };
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075 template <typename KeyType, typename LessKey>
00076 LockSet<KeyType, LessKey>::LockSet()
00077 : __mutex(new Mutex())
00078 {}
00079
00080
00081
00082
00083
00084 template <typename KeyType, typename LessKey>
00085 LockSet<KeyType, LessKey>::LockSet(const LockSet<KeyType, LessKey> &lm)
00086 : std::set<KeyType, LessKey>::set(lm),
00087 __mutex(new Mutex())
00088 {}
00089
00090
00091
00092 template <typename KeyType, typename LessKey>
00093 LockSet<KeyType, LessKey>::~LockSet()
00094 {}
00095
00096
00097
00098 template <typename KeyType, typename LessKey>
00099 void
00100 LockSet<KeyType, LessKey>::lock() const
00101 {
00102 __mutex->lock();
00103 }
00104
00105
00106
00107
00108
00109 template <typename KeyType, typename LessKey>
00110 bool
00111 LockSet<KeyType, LessKey>::try_lock() const
00112 {
00113 return __mutex->try_lock();
00114 }
00115
00116
00117
00118 template <typename KeyType, typename LessKey>
00119 void
00120 LockSet<KeyType, LessKey>::unlock() const
00121 {
00122 return __mutex->unlock();
00123 }
00124
00125
00126
00127
00128
00129
00130
00131 template <typename KeyType, typename LessKey>
00132 std::pair<typename LockSet<KeyType, LessKey>::iterator, bool>
00133 LockSet<KeyType, LessKey>::insert_locked(const KeyType &key)
00134 {
00135 __mutex->lock();
00136 std::pair<iterator, bool> ret =
00137 std::set<KeyType, LessKey>::insert(key);
00138 __mutex->unlock();
00139 return ret;
00140 }
00141
00142
00143
00144
00145
00146 template <typename KeyType, typename LessKey>
00147 void
00148 LockSet<KeyType, LessKey>::erase_locked(const KeyType &key)
00149 {
00150 __mutex->lock();
00151 std::set<KeyType, LessKey>::erase(key);
00152 __mutex->unlock();
00153 }
00154
00155
00156
00157
00158
00159
00160 template <typename KeyType, typename LessKey>
00161 RefPtr<Mutex>
00162 LockSet<KeyType, LessKey>::mutex() const
00163 {
00164 return __mutex;
00165 }
00166
00167
00168
00169
00170
00171
00172
00173
00174 template <typename KeyType, typename LessKey>
00175 LockSet<KeyType, LessKey> &
00176 LockSet<KeyType, LessKey>::operator=(const LockSet<KeyType, LessKey> &ll)
00177 {
00178 __mutex->lock();
00179 ll.lock();
00180 this->clear();
00181 typename LockSet<KeyType, LessKey>::const_iterator i;
00182 for (i = ll.begin(); i != ll.end(); ++i) {
00183 this->insert(*i);
00184 }
00185 ll.unlock();
00186 __mutex->unlock();
00187
00188 return *this;
00189 }
00190
00191
00192
00193
00194
00195
00196
00197
00198 template <typename KeyType, typename LessKey>
00199 LockSet<KeyType, LessKey> &
00200 LockSet<KeyType, LessKey>::operator=(const std::set<KeyType, LessKey> &l)
00201 {
00202 __mutex->lock();
00203 this->clear();
00204 typename std::set<KeyType, LessKey>::const_iterator i;
00205 for (i = l.begin(); i != l.end(); ++i) {
00206 this->insert(*i);
00207 }
00208 __mutex->unlock();
00209
00210 return *this;
00211 }
00212
00213
00214 }
00215
00216 #endif