Merge remote-tracking branch 'origin/master' into 4.3.4

Conflicts:
	src/server/authserver/Main.cpp
	src/server/authserver/Realms/RealmList.cpp
	src/server/authserver/Realms/RealmList.h
	src/server/authserver/Server/AuthSession.cpp
	src/server/authserver/Server/AuthSocket.h
	src/server/authserver/Server/RealmAcceptor.h
	src/server/game/Accounts/AccountMgr.h
	src/server/game/Achievements/AchievementMgr.cpp
	src/server/game/Achievements/AchievementMgr.h
	src/server/game/Battlegrounds/ArenaTeamMgr.cpp
	src/server/game/Conditions/ConditionMgr.cpp
	src/server/game/DungeonFinding/LFGMgr.h
	src/server/game/Entities/Object/Object.h
	src/server/game/Entities/Player/Player.cpp
	src/server/game/Entities/Player/Player.h
	src/server/game/Entities/Unit/Unit.cpp
	src/server/game/Handlers/BattleGroundHandler.cpp
	src/server/game/Movement/Spline/MoveSplineFlag.h
	src/server/game/Quests/QuestDef.cpp
	src/server/game/Quests/QuestDef.h
	src/server/game/Server/WorldSession.cpp
	src/server/game/Server/WorldSession.h
	src/server/game/Server/WorldSocket.cpp
	src/server/game/Server/WorldSocket.h
	src/server/game/Spells/Spell.cpp
	src/server/scripts/Commands/cs_debug.cpp
	src/server/scripts/OutdoorPvP/OutdoorPvPEP.cpp
	src/server/scripts/Spells/spell_mage.cpp
	src/server/scripts/Spells/spell_rogue.cpp
	src/server/scripts/Spells/spell_shaman.cpp
	src/server/scripts/Spells/spell_warrior.cpp
	src/server/shared/Cryptography/BigNumber.h
	src/server/worldserver/RemoteAccess/RASocket.cpp
	src/server/worldserver/worldserver.conf.dist

1 files changed, 113 insertions, 127 deletions

diff --git a/src/server/shared/Threading/LockedQueue.h b/src/server/shared/Threading/LockedQueue.h
index 5709724c9a2..bbd60cb7760 100644
--- a/src/server/shared/Threading/LockedQueue.h
+++ b/src/server/shared/Threading/LockedQueue.h
@@ -19,140 +19,126 @@
 #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();
+
+        _queue.push_back(item);
 
-        public:
+        unlock();
+    }
+
+    //! Gets the next result in the queue, if any.
+    bool next(T& result)
+    {
+        std::lock_guard<std::mutex> lock(_lock);
 
-            //! Create a LockedQueue.
-            LockedQueue()
-                : _canceled(false)
-            {
-            }
+        if (_queue.empty())
+            return false;
 
-            //! Destroy a LockedQueue.
-            virtual ~LockedQueue()
-            {
-            }
-
-            //! Adds an item to the queue.
-            void add(const T& item)
-            {
-                lock();
-
-                //ASSERT(!this->_canceled);
-                // throw Cancellation_Exception();
-
-                _queue.push_back(item);
-
-                unlock();
-            }
-
-            //! 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;
-
-                //ASSERT (!_queue.empty() || !this->_canceled);
-                // throw Cancellation_Exception();
-                result = _queue.front();
-                _queue.pop_front();
-
-                return true;
-            }
-
-            template<class Checker>
-            bool next(T& result, Checker& check)
-            {
-                ACE_Guard<LockType> g(this->_lock);
-
-                if (_queue.empty())
-                    return false;
-
-                result = _queue.front();
-                if (!check.Process(result))
-                    return false;
-
-                _queue.pop_front();
-                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();
-
-                T& result = _queue.front();
-
-                if (autoUnlock)
-                    unlock();
-
-                return result;
-            }
-
-            //! Cancels the queue.
-            void cancel()
-            {
-                lock();
-
-                _canceled = true;
-
-                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();
-            }
-    };
-}
+        result = _queue.front();
+        _queue.pop_front();
+
+        return true;
+    }
+
+    template<class Checker>
+    bool next(T& result, Checker& check)
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+
+        if (_queue.empty())
+            return false;
+
+        result = _queue.front();
+        if (!check.Process(result))
+            return false;
+
+        _queue.pop_front();
+        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();
+
+        T& result = _queue.front();
+
+        if (autoUnlock)
+            unlock();
+
+        return result;
+    }
+
+    //! Cancels the queue.
+    void cancel()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+
+        _canceled = true;
+    }
+
+    //! Checks if the queue is cancelled.
+    bool cancelled()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+        return _canceled;
+    }
+
+    //! Locks the queue for access.
+    void lock()
+    {
+        this->_lock.lock();
+    }
+
+    //! Unlocks the queue.
+    void unlock()
+    {
+        this->_lock.unlock();
+    }
+
+    ///! Calls pop_front of the queue
+    void pop_front()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+        _queue.pop_front();
+    }
+
+    ///! Checks if we're empty or not with locks held
+    bool empty()
+    {
+        std::lock_guard<std::mutex> lock(_lock);
+        return _queue.empty();
+    }
+};
 #endif