refactor(Core/Tools): remove ACE from tools (#3351)

src/common/Threading/PCQueue.h

@@ -0,0 +1,101 @@
+/*
+* Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+*/
+
+#ifndef _PCQ_H
+#define _PCQ_H
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <atomic>
+#include <type_traits>
+
+template <typename T>
+class ProducerConsumerQueue
+{
+private:
+    std::mutex _queueLock;
+    std::queue<T> _queue;
+    std::condition_variable _condition;
+    std::atomic<bool> _shutdown;
+
+public:
+
+    ProducerConsumerQueue<T>() : _shutdown(false) { }
+
+    void Push(const T& value)
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+        _queue.push(std::move(value));
+
+        _condition.notify_one();
+    }
+
+    bool Empty()
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+
+        return _queue.empty();
+    }
+
+    bool Pop(T& value)
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+
+        if (_queue.empty() || _shutdown)
+            return false;
+
+        value = _queue.front();
+
+        _queue.pop();
+
+        return true;
+    }
+
+    void WaitAndPop(T& value)
+    {
+        std::unique_lock<std::mutex> lock(_queueLock);
+
+        // we could be using .wait(lock, predicate) overload here but it is broken
+        // https://connect.microsoft.com/VisualStudio/feedback/details/1098841
+        while (_queue.empty() && !_shutdown)
+            _condition.wait(lock);
+
+        if (_queue.empty() || _shutdown)
+            return;
+
+        value = _queue.front();
+
+        _queue.pop();
+    }
+
+    void Cancel()
+    {
+        std::unique_lock<std::mutex> lock(_queueLock);
+
+        while (!_queue.empty())
+        {
+            T& value = _queue.front();
+
+            DeleteQueuedObject(value);
+
+            _queue.pop();
+        }
+
+        _shutdown = true;
+
+        _condition.notify_all();
+    }
+
+private:
+    template<typename E = T>
+    typename std::enable_if<std::is_pointer<E>::value>::type DeleteQueuedObject(E& obj) { delete obj; }
+
+    template<typename E = T>
+    typename std::enable_if<!std::is_pointer<E>::value>::type DeleteQueuedObject(E const& /*packet*/) { }
+};
+
+#endif

src/common/Threading/PolicyLock.h

@@ -0,0 +1,16 @@
+/*
+* Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+*/
+
+#ifndef POLICYLOCK_H
+#define POLICYLOCK_H
+
+#include <mutex>
+
+#define RETURN_GUARD(mutex, retval) if (!mutex.try_lock())    \
+                                        return retval;        \
+                                    std::lock_guard<decltype(mutex)> guard(mutex, std::adopt_lock)
+
+#endif

src/common/Threading/ThreadingModel.h

@@ -0,0 +1,144 @@
+/*
+* Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+*/
+
+#ifndef ACORE_THREADINGMODEL_H
+#define ACORE_THREADINGMODEL_H
+
+/**
+ * @class ThreadingModel<T>
+ *
+ */
+
+#include "Define.h"
+
+namespace acore
+{
+    template<typename MUTEX>
+    class GeneralLock
+    {
+        public:
+
+            GeneralLock(MUTEX& m)
+                : i_mutex(m)
+            {
+                i_mutex.lock();
+            }
+
+            ~GeneralLock()
+            {
+                i_mutex.unlock();
+            }
+
+        private:
+
+            GeneralLock(const GeneralLock&);
+            GeneralLock& operator=(const GeneralLock&);
+            MUTEX& i_mutex;
+    };
+
+    template<class T>
+    class SingleThreaded
+    {
+        public:
+
+            struct Lock                                     // empty object
+            {
+                Lock()
+                {
+                }
+                Lock(const T&)
+                {
+                }
+
+                Lock(const SingleThreaded<T>&)              // for single threaded we ignore this
+                {
+                }
+            };
+    };
+
+    template<class T, class MUTEX>
+    class ObjectLevelLockable
+    {
+        public:
+
+            ObjectLevelLockable()
+                : i_mtx()
+            {
+            }
+
+            friend class Lock;
+
+            class Lock
+            {
+                public:
+
+                    Lock(ObjectLevelLockable<T, MUTEX>& host)
+                        : i_lock(host.i_mtx)
+                    {
+                    }
+
+                private:
+
+                    GeneralLock<MUTEX> i_lock;
+            };
+
+        private:
+
+            // prevent the compiler creating a copy construct
+            ObjectLevelLockable(const ObjectLevelLockable<T, MUTEX>&);
+            ObjectLevelLockable<T, MUTEX>& operator=(const ObjectLevelLockable<T, MUTEX>&);
+
+            MUTEX i_mtx;
+    };
+
+    template<class T, class MUTEX>
+    class ClassLevelLockable
+    {
+        public:
+
+            ClassLevelLockable()
+            {
+            }
+
+            friend class Lock;
+
+            class Lock
+            {
+                public:
+
+                    Lock(const T& /*host*/)
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
+                    }
+
+                    Lock(const ClassLevelLockable<T, MUTEX>&)
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
+                    }
+
+                    Lock()
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.lock();
+                    }
+
+                    ~Lock()
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.unlock();
+                    }
+            };
+
+        private:
+
+            static MUTEX si_mtx;
+    };
+}
+
+template<class T, class MUTEX> MUTEX acore::ClassLevelLockable<T, MUTEX>::si_mtx;
+
+#define INSTANTIATE_CLASS_MUTEX(CTYPE, MUTEX) \
+    template class acore::ClassLevelLockable<CTYPE, MUTEX>
+
+#endif