Merge branch 'ace2' into devcopy

contrib/mmap/CMakeLists.txt

@@ -28,7 +28,6 @@ include_directories(
     ../../src/shared
     ../../src/game
     ../../src/game/vmap
-    ../../src/game/Maps
     ../../src/game/Commands
     ../../dep/include/g3dlite
     ../../src/framework

contrib/mmap/src/TerrainBuilder.cpp

@@ -604,7 +604,7 @@ namespace MMAP
             ModelInstance& instance = models[i];
 
             // model instances exist in tree even though there are instances of that model in this tile
-            std::shared_ptr<WorldModel> worldModel = instance.getWorldModel();
+            WorldModel* worldModel = instance.getWorldModel();
             if (!worldModel)
                 continue;
 
@@ -731,7 +731,7 @@ namespace MMAP
             ModelInstance instance = models[i];
 
             // model instances exist in tree even though there are instances of that model in this tile
-            std::shared_ptr<WorldModel> worldModel = instance.getWorldModel();
+            WorldModel* worldModel = instance.getWorldModel();
             if (!worldModel)
                 continue;
 

dep/loadlib/CMakeLists.txt

@@ -23,7 +23,6 @@ include_directories(
 )
 
 # link loadlib with zlib
-
 if(UNIX)
   find_package(ZLIB REQUIRED)
   if(ZLIB_FOUND)

src/framework/Network/MangosSocket.h

@@ -9,9 +9,10 @@
 #include <ace/SOCK_Connector.h>
 #include <ace/Acceptor.h>
 #include <ace/Connector.h>
+#include <ace/Thread_Mutex.h>
+#include <ace/Guard_T.h>
 #include <ace/Unbounded_Queue.h>
 #include <ace/Message_Block.h>
-#include <mutex>
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 #pragma once
@@ -101,9 +102,9 @@ class MangosSocket : public WorldHandler
         friend class ACE_Connector<SocketName, ACE_SOCK_CONNECTOR>;
         friend class ACE_NonBlocking_Connect_Handler<SocketName>;
 
-        // Mutex type used for various synchronizations.
-        using LockType = std::mutex;
-        typedef std::unique_lock<LockType> GuardType;
+        /// Mutex type used for various synchronizations.
+        typedef ACE_Thread_Mutex LockType;
+        typedef ACE_Guard<LockType> GuardType;
 
         // Queue for storing packets for which there is no space.
         typedef ACE_Unbounded_Queue<WorldPacket*> PacketQueueT;

src/framework/Network/MangosSocketImpl.h

@@ -7,6 +7,7 @@
 #include <ace/os_include/sys/os_socket.h>
 #include <ace/OS_NS_string.h>
 #include <ace/Reactor.h>
+#include <ace/Auto_Ptr.h>
 
 #include "MangosSocket.h"
 #include "Common.h"
@@ -62,7 +63,7 @@ template <typename SessionType, typename SocketName, typename Crypt>
 void MangosSocket<SessionType, SocketName, Crypt>::CloseSocket(void)
 {
     {
-        GuardType lock(m_OutBufferLock);
+        ACE_GUARD(LockType, Guard, m_OutBufferLock);
 
         if (closing_)
             return;
@@ -72,7 +73,7 @@ void MangosSocket<SessionType, SocketName, Crypt>::CloseSocket(void)
     }
 
     {
-        GuardType lock(m_SessionLock);
+        ACE_GUARD(LockType, Guard, m_SessionLock);
 
         m_Session = nullptr;
     }
@@ -81,7 +82,7 @@ void MangosSocket<SessionType, SocketName, Crypt>::CloseSocket(void)
 template <typename SessionType, typename SocketName, typename Crypt>
 int MangosSocket<SessionType, SocketName, Crypt>::SendPacket(const WorldPacket& pct)
 {
-    GuardType lock(m_OutBufferLock);
+    ACE_GUARD_RETURN(LockType, Guard, m_OutBufferLock, -1);
 
     if (closing_)
         return -1;
@@ -204,15 +205,15 @@ int MangosSocket<SessionType, SocketName, Crypt>::handle_input(ACE_HANDLE)
 template <typename SessionType, typename SocketName, typename Crypt>
 int MangosSocket<SessionType, SocketName, Crypt>::handle_output(ACE_HANDLE)
 {
-    GuardType lock(m_OutBufferLock);
+    ACE_GUARD_RETURN(LockType, Guard, m_OutBufferLock, -1);
 
     if (closing_)
         return -1;
 
     const size_t send_len = m_OutBuffer->length();
 
     if (send_len == 0)
-        return cancel_wakeup_output(lock);
+        return cancel_wakeup_output(Guard);
 
 #ifdef MSG_NOSIGNAL
     ssize_t n = peer().send(m_OutBuffer->rd_ptr(), send_len, MSG_NOSIGNAL);
@@ -230,7 +231,7 @@ int MangosSocket<SessionType, SocketName, Crypt>::handle_output(ACE_HANDLE)
 #endif
 
         if (errno == EWOULDBLOCK || errno == EAGAIN)
-            return schedule_wakeup_output(lock);
+            return schedule_wakeup_output(Guard);
 
         return -1;
     }
@@ -241,16 +242,16 @@ int MangosSocket<SessionType, SocketName, Crypt>::handle_output(ACE_HANDLE)
         // move the data to the base of the buffer
         m_OutBuffer->crunch();
 
-        return schedule_wakeup_output(lock);
+        return schedule_wakeup_output(Guard);
     }
     else //now n == send_len
     {
         m_OutBuffer->reset();
 
         if (!iFlushPacketQueue())
-            return cancel_wakeup_output(lock);
+            return cancel_wakeup_output(Guard);
         else
-            return schedule_wakeup_output(lock);
+            return schedule_wakeup_output(Guard);
     }
 
     ACE_NOTREACHED(return 0);
@@ -261,7 +262,7 @@ int MangosSocket<SessionType, SocketName, Crypt>::handle_close(ACE_HANDLE h, ACE
 {
     // Critical section
     {
-        GuardType lock(m_OutBufferLock);
+        ACE_GUARD_RETURN(LockType, Guard, m_OutBufferLock, -1);
 
         closing_ = true;
 
@@ -271,7 +272,7 @@ int MangosSocket<SessionType, SocketName, Crypt>::handle_close(ACE_HANDLE h, ACE
 
     // Critical section
     {
-        GuardType lock(m_SessionLock);
+        ACE_GUARD_RETURN(LockType, Guard, m_SessionLock, -1);
 
         m_Session = nullptr;
     }
@@ -452,7 +453,7 @@ int MangosSocket<SessionType, SocketName, Crypt>::cancel_wakeup_output(GuardType
 
     m_OutActive = false;
 
-    g.unlock();
+    g.release();
 
     if (reactor()->cancel_wakeup
             (this, ACE_Event_Handler::WRITE_MASK) == -1)
@@ -473,7 +474,7 @@ int MangosSocket<SessionType, SocketName, Crypt>::schedule_wakeup_output(GuardTy
 
     m_OutActive = true;
 
-    g.unlock();
+    g.release();
 
     if (reactor()->schedule_wakeup
             (this, ACE_Event_Handler::WRITE_MASK) == -1)

src/framework/Network/MangosSocketMgr.h

@@ -2,6 +2,8 @@
 #define MANGOSSOCKETMGR_H
 
 #include <ace/Basic_Types.h>
+#include <ace/Singleton.h>
+#include <ace/Thread_Mutex.h>
 
 #include <string>
 

src/framework/Network/MangosSocketMgrImpl.h

@@ -8,6 +8,7 @@
 #include <ace/TP_Reactor.h>
 #include <ace/Dev_Poll_Reactor.h>
 #include <ace/Guard_T.h>
+#include <ace/Atomic_Op.h>
 #include <ace/os_include/arpa/os_inet.h>
 #include <ace/os_include/netinet/os_tcp.h>
 #include <ace/os_include/sys/os_types.h>
@@ -16,7 +17,6 @@
 #include <ace/SOCK_Acceptor.h>
 
 #include <set>
-#include <atomic>
 
 #include "Log.h"
 #include "Common.h"
@@ -121,12 +121,12 @@ class ReactorRunnable : protected ACE_Task_Base
 
     long Connections()
     {
-        return m_Connections;
+        return static_cast<long>(m_Connections.value());
     }
 
     int AddSocket(SocketType* sock)
     {
-        std::unique_lock<std::mutex> lock(m_NewSockets_Lock);
+        ACE_GUARD_RETURN(ACE_Thread_Mutex, Guard, m_NewSockets_Lock, -1);
 
         ++m_Connections;
         sock->AddReference();
@@ -144,7 +144,7 @@ class ReactorRunnable : protected ACE_Task_Base
 protected:
     void AddNewSockets()
     {
-        std::unique_lock<std::mutex> lock(m_NewSockets_Lock);
+        ACE_GUARD(ACE_Thread_Mutex, Guard, m_NewSockets_Lock);
 
         if (m_NewSockets.empty())
             return;
@@ -210,7 +210,7 @@ class ReactorRunnable : protected ACE_Task_Base
     }
 
 private:
-    using AtomicInt = std::atomic<int>;
+    typedef ACE_Atomic_Op<ACE_SYNCH_MUTEX, int> AtomicInt;
     typedef std::set<SocketType*> SocketSet;
 
     ACE_Reactor* m_Reactor;
@@ -221,7 +221,7 @@ class ReactorRunnable : protected ACE_Task_Base
     SocketSet m_Sockets;
 
     SocketSet m_NewSockets;
-    std::mutex m_NewSockets_Lock;
+    ACE_Thread_Mutex m_NewSockets_Lock;
 };
 
 template <typename SocketType>

src/framework/Policies/ThreadingModel.h

@@ -28,7 +28,6 @@
  */
 
 #include "Platform/Define.h"
-#include <mutex>
 
 namespace MaNGOS
 {
@@ -40,63 +39,115 @@ namespace MaNGOS
             GeneralLock(MUTEX &m)
                 : i_mutex(m)
             {
+                i_mutex.acquire();
             }
 
             ~GeneralLock()
             {
+                i_mutex.release();
             }
 
-            GeneralLock(const GeneralLock &) = delete;
-            GeneralLock& operator=(const GeneralLock &) = delete;
         private:
 
+            GeneralLock(const GeneralLock &);
+            GeneralLock& operator=(const GeneralLock &);
             MUTEX &i_mutex;
-            std::unique_lock<MUTEX> m_lock{i_mutex};
-
     };
 
     template<class T>
     class SingleThreaded
     {
-    public:
+        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:
 
-        struct Lock                                     // empty object
-        {
-            Lock() = default;
+            ObjectLevelLockable()
+                : i_mtx()
+            {
+            }
+
+            friend class Lock;
+
+            class Lock
+            {
+                public:
 
-            Lock(const T&) { }
+                    Lock(ObjectLevelLockable<T, MUTEX> &host)
+                        : i_lock(host.i_mtx)
+                    {
+                    }
 
-            Lock(const SingleThreaded<T>&) { }          // for single threaded we ignore this
-        };
+                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:
+        public:
 
-        ClassLevelLockable()
-        {
-        }
+            ClassLevelLockable()
+            {
+            }
 
-        friend class Lock;
+            friend class Lock;
 
-        class Lock
-        {
-        public:
+            class Lock
+            {
+                public:
 
-            Lock(const T& /*host*/) { }
+                    Lock(const T& /*host*/)
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
+                    }
 
-            Lock(const ClassLevelLockable<T, MUTEX> &) { }
+                    Lock(const ClassLevelLockable<T, MUTEX> &)
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
+                    }
 
-            Lock() = default;
-        private:
-            std::unique_lock<MUTEX> m_lock{si_mtx};
-        };
+                    Lock()
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.acquire();
+                    }
+
+                    ~Lock()
+                    {
+                        ClassLevelLockable<T, MUTEX>::si_mtx.release();
+                    }
+            };
 
-    private:
+        private:
 
-        static MUTEX si_mtx;
+            static MUTEX si_mtx;
     };
 
 }