lock_queue.h
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef __CORE_UTILS_LOCK_QUEUE_H_
00025 #define __CORE_UTILS_LOCK_QUEUE_H_
00026
00027 #include <core/threading/mutex.h>
00028 #include <core/utils/refptr.h>
00029 #include <queue>
00030
00031 namespace fawkes {
00032
00033 template <typename Type>
00034 class LockQueue : public std::queue<Type>
00035 {
00036 public:
00037 LockQueue();
00038 LockQueue(const LockQueue<Type> &ll);
00039 virtual ~LockQueue();
00040
00041 void lock() const;
00042 bool try_lock() const;
00043 void unlock() const;
00044 RefPtr<Mutex> mutex() const;
00045
00046 void push_locked(const Type& x);
00047 void pop_locked();
00048
00049 void clear();
00050
00051
00052
00053 private:
00054 mutable RefPtr<Mutex> __mutex;
00055
00056 };
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071 template <typename Type>
00072 LockQueue<Type>::LockQueue()
00073 : __mutex(new Mutex())
00074 {}
00075
00076
00077
00078
00079
00080 template <typename Type>
00081 LockQueue<Type>::LockQueue(const LockQueue<Type> &ll)
00082 : std::queue<Type>::queue(ll), __mutex(new Mutex())
00083 {}
00084
00085
00086
00087 template <typename Type>
00088 LockQueue<Type>::~LockQueue()
00089 {}
00090
00091
00092
00093 template <typename Type>
00094 void
00095 LockQueue<Type>::lock() const
00096 {
00097 __mutex->lock();
00098 }
00099
00100
00101
00102
00103
00104 template <typename Type>
00105 bool
00106 LockQueue<Type>::try_lock() const
00107 {
00108 return __mutex->try_lock();
00109 }
00110
00111
00112
00113 template <typename Type>
00114 void
00115 LockQueue<Type>::unlock() const
00116 {
00117 return __mutex->unlock();
00118 }
00119
00120
00121
00122
00123
00124 template <typename Type>
00125 void
00126 LockQueue<Type>::push_locked(const Type& x)
00127 {
00128 __mutex->lock();
00129 std::queue<Type>::push(x);
00130 __mutex->unlock();
00131 }
00132
00133
00134
00135
00136 template <typename Type>
00137 void
00138 LockQueue<Type>::pop_locked()
00139 {
00140 __mutex->lock();
00141 std::queue<Type>::pop();
00142 __mutex->unlock();
00143 }
00144
00145
00146 template <typename Type>
00147 void
00148 LockQueue<Type>::clear()
00149 {
00150 __mutex->lock();
00151 while ( ! std::queue<Type>::empty() ) {
00152 std::queue<Type>::pop();
00153 }
00154 __mutex->unlock();
00155 }
00156
00157
00158
00159
00160
00161
00162 template <typename Type>
00163 RefPtr<Mutex>
00164 LockQueue<Type>::mutex() const
00165 {
00166 return __mutex;
00167 }
00168
00169
00170 }
00171
00172 #endif