Replaced LockedQueue ACE lock with std::mutex

src/server/shared/Threading/LockedQueue.h

@@ -19,140 +19,130 @@
 #ifndef LOCKEDQUEUE_H
 #define LOCKEDQUEUE_H
 
-#include <ace/Guard_T.h>
-#include <ace/Thread_Mutex.h>
 #include <deque>
-#include <assert.h>
-#include "Debugging/Errors.h"
+#include <mutex>
 
-namespace ACE_Based
+
+
+template <class T, typename StorageType = std::deque<T> >
+class LockedQueue
 {
-    template <class T, class LockType, typename StorageType=std::deque<T> >
-        class LockedQueue
+    //! Lock access to the queue.
+    std::mutex _lock;
+
+    //! Storage backing the queue.
+    StorageType _queue;
+
+    //! Cancellation flag.
+    volatile bool _canceled;
+
+public:
+
+    //! Create a LockedQueue.
+    LockedQueue()
+        : _canceled(false)
     {
-        //! Lock access to the queue.
-        LockType _lock;
+    }
 
-        //! Storage backing the queue.
-        StorageType _queue;
+    //! Destroy a LockedQueue.
+    virtual ~LockedQueue()
+    {
+    }
 
-        //! Cancellation flag.
-        volatile bool _canceled;
+    //! Adds an item to the queue.
+    void add(const T& item)
+    {
+        lock();
 
-        public:
+        _queue.push_back(item);
 
-            //! Create a LockedQueue.
-            LockedQueue()
-                : _canceled(false)
-            {
-            }
+        unlock();
+    }
 
-            //! Destroy a LockedQueue.
-            virtual ~LockedQueue()
-            {
-            }
+    //! Gets the next result in the queue, if any.
+    bool next(T& result)
+    {
+        std::lock_guard<std::mutex> lock(_lock);
 
-            //! Adds an item to the queue.
-            void add(const T& item)
-            {
-                lock();
+        if (_queue.empty())
+            return false;
 
-                //ASSERT(!this->_canceled);
-                // throw Cancellation_Exception();
+        result = _queue.front();
+        _queue.pop_front();
 
-                _queue.push_back(item);
+        return true;
+    }
 
-                unlock();
-            }
+    template<class Checker>
+    bool next(T& result, Checker& check)
+    {
+        std::lock_guard<std::mutex> lock(_lock);
 
-            //! Gets the next result in the queue, if any.
-            bool next(T& result)
-            {
-               // ACE_Guard<LockType> g(this->_lock);
-                ACE_GUARD_RETURN (LockType, g, this->_lock, false);
+        if (_queue.empty())
+            return false;
 
-                if (_queue.empty())
-                    return false;
+        result = _queue.front();
+        if (!check.Process(result))
+            return false;
 
-                //ASSERT (!_queue.empty() || !this->_canceled);
-                // throw Cancellation_Exception();
-                result = _queue.front();
-                _queue.pop_front();
+        _queue.pop_front();
+        return true;
+    }
 
-                return true;
-            }
+    //! Peeks at the top of the queue. Check if the queue is empty before calling! Remember to unlock after use if autoUnlock == false.
+    T& peek(bool autoUnlock = false)
+    {
+        lock();
 
-            template<class Checker>
-            bool next(T& result, Checker& check)
-            {
-                ACE_Guard<LockType> g(this->_lock);
+        T& result = _queue.front();
 
-                if (_queue.empty())
-                    return false;
+        if (autoUnlock)
+            unlock();
 
-                result = _queue.front();
-                if (!check.Process(result))
-                    return false;
+        return result;
+    }
 
-                _queue.pop_front();
-                return true;
-            }
+    //! Cancels the queue.
+    void cancel()
+    {
+        lock();
 
-            //! Peeks at the top of the queue. Check if the queue is empty before calling! Remember to unlock after use if autoUnlock == false.
-            T& peek(bool autoUnlock = false)
-            {
-                lock();
+        _canceled = true;
 
-                T& result = _queue.front();
+        unlock();
+    }
 
-                if (autoUnlock)
-                    unlock();
+    //! Checks if the queue is cancelled.
+    bool cancelled()
+    {
+        ACE_Guard<LockType> g(this->_lock);
+        return _canceled;
+    }
 
-                return result;
-            }
+    //! Locks the queue for access.
+    void lock()
+    {
+        this->_lock.lock();
+    }
 
-            //! Cancels the queue.
-            void cancel()
-            {
-                lock();
+    //! Unlocks the queue.
+    void unlock()
+    {
+        this->_lock.unlock();
+    }
 
-                _canceled = true;
+    ///! Calls pop_front of the queue
+    void pop_front()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+        _queue.pop_front();
+    }
 
-                unlock();
-            }
-
-            //! Checks if the queue is cancelled.
-            bool cancelled()
-            {
-                ACE_Guard<LockType> g(this->_lock);
-                return _canceled;
-            }
-
-            //! Locks the queue for access.
-            void lock()
-            {
-                this->_lock.acquire();
-            }
-
-            //! Unlocks the queue.
-            void unlock()
-            {
-                this->_lock.release();
-            }
-
-            ///! Calls pop_front of the queue
-            void pop_front()
-            {
-                ACE_GUARD (LockType, g, this->_lock);
-                _queue.pop_front();
-            }
-
-            ///! Checks if we're empty or not with locks held
-            bool empty()
-            {
-                ACE_GUARD_RETURN (LockType, g, this->_lock, false);
-                return _queue.empty();
-            }
-    };
-}
+    ///! Checks if we're empty or not with locks held
+    bool empty()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+        return _queue.empty();
+    }
+};
 #endif