Core/Databases: Removed ACE dependencies on some of the database handling code.

12 files changed, 72 insertions, 76 deletions

diff --git a/src/server/game/Server/WorldSession.cpp b/src/server/game/Server/WorldSession.cpp
index 9f8b3785e92..0c391993c0b 100644
--- a/src/server/game/Server/WorldSession.cpp
+++ b/src/server/game/Server/WorldSession.cpp
@@ -1105,27 +1105,23 @@ void WorldSession::ProcessQueryCallbacks()
     PreparedQueryResult result;
 
     //! HandleCharEnumOpcode
-    if (_charEnumCallback.ready())
+    if (_charEnumCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
-        _charEnumCallback.get(result);
+        result = _charEnumCallback.get();
         HandleCharEnum(result);
-        _charEnumCallback.cancel();
     }
 
     if (_charCreateCallback.IsReady())
     {
         _charCreateCallback.GetResult(result);
         HandleCharCreateCallback(result, _charCreateCallback.GetParam());
-        // Don't call FreeResult() here, the callback handler will do that depending on the events in the callback chain
     }
 
     //! HandlePlayerLoginOpcode
-    if (_charLoginCallback.ready())
+    if (_charLoginCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
-        SQLQueryHolder* param;
-        _charLoginCallback.get(param);
+        SQLQueryHolder* param = _charLoginCallback.get();
         HandlePlayerLogin((LoginQueryHolder*)param);
-        _charLoginCallback.cancel();
     }
 
     //! HandleAddFriendOpcode
@@ -1147,11 +1143,10 @@ void WorldSession::ProcessQueryCallbacks()
     }
 
     //- HandleCharAddIgnoreOpcode
-    if (_addIgnoreCallback.ready())
+    if (_addIgnoreCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
-        _addIgnoreCallback.get(result);
+        result = _addIgnoreCallback.get();
         HandleAddIgnoreOpcodeCallBack(result);
-        _addIgnoreCallback.cancel();
     }
 
     //- SendStabledPet
@@ -1164,11 +1159,10 @@ void WorldSession::ProcessQueryCallbacks()
     }
 
     //- HandleStablePet
-    if (_stablePetCallback.ready())
+    if (_stablePetCallback.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
     {
-        _stablePetCallback.get(result);
+        result = _stablePetCallback.get();
         HandleStablePetCallback(result);
-        _stablePetCallback.cancel();
     }
 
     //- HandleUnstablePet
diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp
index e5b207d9b46..234a366b08e 100644
--- a/src/server/game/World/World.cpp
+++ b/src/server/game/World/World.cpp
@@ -2731,7 +2731,7 @@ void World::UpdateRealmCharCount(uint32 accountId)
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_COUNT);
     stmt->setUInt32(0, accountId);
     PreparedQueryResultFuture result = CharacterDatabase.AsyncQuery(stmt);
-    m_realmCharCallbacks.insert(result);
+    m_realmCharCallbacks.push_back(std::move(result));
 }
 
 void World::_UpdateRealmCharCount(PreparedQueryResult resultCharCount)
@@ -3088,19 +3088,17 @@ void World::ProcessQueryCallbacks()
 {
     PreparedQueryResult result;
 
-    while (!m_realmCharCallbacks.is_empty())
+    for (std::deque<std::future<PreparedQueryResult>>::iterator itr = m_realmCharCallbacks.begin(); itr != m_realmCharCallbacks.end(); )
     {
-        ACE_Future<PreparedQueryResult> lResult;
-        ACE_Time_Value timeout = ACE_Time_Value::zero;
-        if (m_realmCharCallbacks.next_readable(lResult, &timeout) != 1)
-            break;
-
-        if (lResult.ready())
+        if ((*itr).wait_for(std::chrono::seconds(0)) != std::future_status::ready)
         {
-            lResult.get(result);
-            _UpdateRealmCharCount(result);
-            lResult.cancel();
+            ++itr;
+            continue;
         }
+
+        result = (*itr).get();
+        _UpdateRealmCharCount(result);
+        itr = m_realmCharCallbacks.erase(itr);
     }
 }
 
diff --git a/src/server/game/World/World.h b/src/server/game/World/World.h
index f5c0dd1cb8f..9c68ee8add2 100644
--- a/src/server/game/World/World.h
+++ b/src/server/game/World/World.h
@@ -839,7 +839,7 @@ class World
         void LoadCharacterNameData();
 
         void ProcessQueryCallbacks();
-        ACE_Future_Set<PreparedQueryResult> m_realmCharCallbacks;
+        std::deque<std::future<PreparedQueryResult>> m_realmCharCallbacks;
 };
 
 extern uint32 realmID;
diff --git a/src/server/shared/Database/AdhocStatement.cpp b/src/server/shared/Database/AdhocStatement.cpp
index 896fefde5b7..65c41823ccb 100644
--- a/src/server/shared/Database/AdhocStatement.cpp
+++ b/src/server/shared/Database/AdhocStatement.cpp
@@ -25,9 +25,9 @@ m_has_result(false)
     m_sql = strdup(sql);
 }
 
-BasicStatementTask::BasicStatementTask(const char* sql, QueryResultFuture result) :
+BasicStatementTask::BasicStatementTask(const char* sql, QueryResultPromise& result) :
 m_has_result(true),
-m_result(result)
+m_result(std::move(result))
 {
     m_sql = strdup(sql);
 }
@@ -45,11 +45,11 @@ bool BasicStatementTask::Execute()
         if (!result || !result->GetRowCount() || !result->NextRow())
         {
             delete result;
-            m_result.set(QueryResult(NULL));
+            m_result.set_value(QueryResult(NULL));
             return false;
         }
 
-        m_result.set(QueryResult(result));
+        m_result.set_value(QueryResult(result));
         return true;
     }
 
diff --git a/src/server/shared/Database/AdhocStatement.h b/src/server/shared/Database/AdhocStatement.h
index 44a9fa3d3ee..a67caaa160f 100644
--- a/src/server/shared/Database/AdhocStatement.h
+++ b/src/server/shared/Database/AdhocStatement.h
@@ -18,24 +18,26 @@
 #ifndef _ADHOCSTATEMENT_H
 #define _ADHOCSTATEMENT_H
 
-#include <ace/Future.h>
+#include <future>
 #include "SQLOperation.h"
 
-typedef ACE_Future<QueryResult> QueryResultFuture;
+typedef std::future<QueryResult> QueryResultFuture;
+typedef std::promise<QueryResult> QueryResultPromise;
+
 /*! Raw, ad-hoc query. */
 class BasicStatementTask : public SQLOperation
 {
     public:
         BasicStatementTask(const char* sql);
-        BasicStatementTask(const char* sql, QueryResultFuture result);
+        BasicStatementTask(const char* sql, QueryResultPromise& result);
         ~BasicStatementTask();
 
-        bool Execute();
+        bool Execute() override;
 
     private:
         const char* m_sql;      //- Raw query to be executed
         bool m_has_result;
-        QueryResultFuture m_result;
+        QueryResultPromise m_result;
 };
 
 #endif
\ No newline at end of file
diff --git a/src/server/shared/Database/DatabaseWorkerPool.h b/src/server/shared/Database/DatabaseWorkerPool.h
index 9c56c75bf71..078b97762b5 100644
--- a/src/server/shared/Database/DatabaseWorkerPool.h
+++ b/src/server/shared/Database/DatabaseWorkerPool.h
@@ -307,10 +307,10 @@ class DatabaseWorkerPool
         //! The return value is then processed in ProcessQueryCallback methods.
         QueryResultFuture AsyncQuery(const char* sql)
         {
-            QueryResultFuture res;
+            QueryResultPromise res;
             BasicStatementTask* task = new BasicStatementTask(sql, res);
             Enqueue(task);
-            return res;         //! Actual return value has no use yet
+            return res.get_future();         //! Actual return value has no use yet
         }
 
         //! Enqueues a query in string format -with variable args- that will set the value of the QueryResultFuture return object as soon as the query is executed.
@@ -331,10 +331,10 @@ class DatabaseWorkerPool
         //! Statement must be prepared with CONNECTION_ASYNC flag.
         PreparedQueryResultFuture AsyncQuery(PreparedStatement* stmt)
         {
-            PreparedQueryResultFuture res;
+            PreparedQueryResultPromise res;
             PreparedStatementTask* task = new PreparedStatementTask(stmt, res);
             Enqueue(task);
-            return res;
+            return res.get_future();
         }
 
         //! Enqueues a vector of SQL operations (can be both adhoc and prepared) that will set the value of the QueryResultHolderFuture
@@ -343,10 +343,10 @@ class DatabaseWorkerPool
         //! Any prepared statements added to this holder need to be prepared with the CONNECTION_ASYNC flag.
         QueryResultHolderFuture DelayQueryHolder(SQLQueryHolder* holder)
         {
-            QueryResultHolderFuture res;
+            QueryResultHolderPromise res;
             SQLQueryHolderTask* task = new SQLQueryHolderTask(holder, res);
             Enqueue(task);
-            return res;     //! Fool compiler, has no use yet
+            return res.get_future();     //! Fool compiler, has no use yet
         }
 
         /**
diff --git a/src/server/shared/Database/MySQLConnection.cpp b/src/server/shared/Database/MySQLConnection.cpp
index 55d47c76430..0d2d97f7f28 100644
--- a/src/server/shared/Database/MySQLConnection.cpp
+++ b/src/server/shared/Database/MySQLConnection.cpp
@@ -34,6 +34,8 @@
 #include "Timer.h"
 #include "Log.h"
 
+#include <ace/OS_NS_unistd.h>
+
 MySQLConnection::MySQLConnection(MySQLConnectionInfo& connInfo) :
 m_reconnecting(false),
 m_prepareError(false),
diff --git a/src/server/shared/Database/PreparedStatement.cpp b/src/server/shared/Database/PreparedStatement.cpp
index fe052bf5043..4b2b55f25e5 100644
--- a/src/server/shared/Database/PreparedStatement.cpp
+++ b/src/server/shared/Database/PreparedStatement.cpp
@@ -449,10 +449,10 @@ PreparedStatementTask::PreparedStatementTask(PreparedStatement* stmt) :
 m_stmt(stmt),
 m_has_result(false) { }
 
-PreparedStatementTask::PreparedStatementTask(PreparedStatement* stmt, PreparedQueryResultFuture result) :
+PreparedStatementTask::PreparedStatementTask(PreparedStatement* stmt, PreparedQueryResultPromise& result) :
 m_stmt(stmt),
 m_has_result(true),
-m_result(result) { }
+m_result(std::move(result)) { }
 
 
 PreparedStatementTask::~PreparedStatementTask()
@@ -468,10 +468,10 @@ bool PreparedStatementTask::Execute()
         if (!result || !result->GetRowCount())
         {
             delete result;
-            m_result.set(PreparedQueryResult(NULL));
+            m_result.set_value(PreparedQueryResult(NULL));
             return false;
         }
-        m_result.set(PreparedQueryResult(result));
+        m_result.set_value(PreparedQueryResult(result));
         return true;
     }
 
diff --git a/src/server/shared/Database/PreparedStatement.h b/src/server/shared/Database/PreparedStatement.h
index 6afb309db2c..d69ee52a3e7 100644
--- a/src/server/shared/Database/PreparedStatement.h
+++ b/src/server/shared/Database/PreparedStatement.h
@@ -18,8 +18,8 @@
 #ifndef _PREPAREDSTATEMENT_H
 #define _PREPAREDSTATEMENT_H
 
+#include <future>
 #include "SQLOperation.h"
-#include <ace/Future.h>
 
 #ifdef __APPLE__
 #undef TYPE_BOOL
@@ -153,14 +153,15 @@ class MySQLPreparedStatement
         MySQLPreparedStatement& operator=(MySQLPreparedStatement const& right) = delete;
 };
 
-typedef ACE_Future<PreparedQueryResult> PreparedQueryResultFuture;
+typedef std::future<PreparedQueryResult> PreparedQueryResultFuture;
+typedef std::promise<PreparedQueryResult> PreparedQueryResultPromise;
 
 //- Lower-level class, enqueuable operation
 class PreparedStatementTask : public SQLOperation
 {
     public:
         PreparedStatementTask(PreparedStatement* stmt);
-        PreparedStatementTask(PreparedStatement* stmt, PreparedQueryResultFuture result);
+        PreparedStatementTask(PreparedStatement* stmt, PreparedQueryResultPromise& result);
         ~PreparedStatementTask();
 
         bool Execute();
@@ -168,6 +169,6 @@ class PreparedStatementTask : public SQLOperation
     protected:
         PreparedStatement* m_stmt;
         bool m_has_result;
-        PreparedQueryResultFuture m_result;
+        PreparedQueryResultPromise m_result;
 };
 #endif
diff --git a/src/server/shared/Database/QueryHolder.cpp b/src/server/shared/Database/QueryHolder.cpp
index 7b4105ee076..bd938561b50 100644
--- a/src/server/shared/Database/QueryHolder.cpp
+++ b/src/server/shared/Database/QueryHolder.cpp
@@ -168,9 +168,6 @@ void SQLQueryHolder::SetSize(size_t size)
 
 bool SQLQueryHolderTask::Execute()
 {
-    //the result can't be ready as we are processing it right now
-    ASSERT(!m_result.ready());
-
     if (!m_holder)
         return false;
 
@@ -202,6 +199,6 @@ bool SQLQueryHolderTask::Execute()
         }
     }
 
-    m_result.set(m_holder);
+    m_result.set_value(m_holder);
     return true;
 }
diff --git a/src/server/shared/Database/QueryHolder.h b/src/server/shared/Database/QueryHolder.h
index b92b2e5327e..5751675fe5f 100644
--- a/src/server/shared/Database/QueryHolder.h
+++ b/src/server/shared/Database/QueryHolder.h
@@ -18,7 +18,7 @@
 #ifndef _QUERYHOLDER_H
 #define _QUERYHOLDER_H
 
-#include <ace/Future.h>
+#include <future>
 
 class SQLQueryHolder
 {
@@ -39,17 +39,18 @@ class SQLQueryHolder
         void SetPreparedResult(size_t index, PreparedResultSet* result);
 };
 
-typedef ACE_Future<SQLQueryHolder*> QueryResultHolderFuture;
+typedef std::future<SQLQueryHolder*> QueryResultHolderFuture;
+typedef std::promise<SQLQueryHolder*> QueryResultHolderPromise;
 
 class SQLQueryHolderTask : public SQLOperation
 {
     private:
         SQLQueryHolder * m_holder;
-        QueryResultHolderFuture m_result;
+        QueryResultHolderPromise m_result;
 
     public:
-        SQLQueryHolderTask(SQLQueryHolder *holder, QueryResultHolderFuture res)
-            : m_holder(holder), m_result(res){ };
+        SQLQueryHolderTask(SQLQueryHolder *holder, QueryResultHolderPromise& res)
+            : m_holder(holder), m_result(std::move(res)){ };
         bool Execute();
 
 };
diff --git a/src/server/shared/Threading/Callback.h b/src/server/shared/Threading/Callback.h
index c48546bbf5c..a6aa11b3958 100644
--- a/src/server/shared/Threading/Callback.h
+++ b/src/server/shared/Threading/Callback.h
@@ -18,12 +18,13 @@
 #ifndef _CALLBACK_H
 #define _CALLBACK_H
 
-#include <ace/Future.h>
-#include <ace/Future_Set.h>
+#include <future>
 #include "QueryResult.h"
 
-typedef ACE_Future<QueryResult> QueryResultFuture;
-typedef ACE_Future<PreparedQueryResult> PreparedQueryResultFuture;
+typedef std::future<QueryResult> QueryResultFuture;
+typedef std::promise<QueryResult> QueryResultPromise;
+typedef std::future<PreparedQueryResult> PreparedQueryResultFuture;
+typedef std::promise<PreparedQueryResult> PreparedQueryResultPromise;
 
 /*! A simple template using ACE_Future to manage callbacks from the thread and object that
     issued the request. <ParamType> is variable type of parameter that is used as parameter
@@ -38,29 +39,29 @@ class QueryCallback
         QueryCallback() : _param(), _stage(chain ? 0 : CALLBACK_STAGE_INVALID)  { }
 
         //! The parameter of this function should be a resultset returned from either .AsyncQuery or .AsyncPQuery
-        void SetFutureResult(ACE_Future<Result> value)
+        void SetFutureResult(std::future<Result>& value)
         {
-            _result = value;
+            _result = std::move(value);
         }
 
-        ACE_Future<Result> GetFutureResult()
+        std::future<Result>& GetFutureResult()
         {
             return _result;
         }
 
         int IsReady()
         {
-            return _result.ready();
+            return _result.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
         }
 
         void GetResult(Result& res)
         {
-            _result.get(res);
+            res = _result.get();
         }
 
         void FreeResult()
         {
-            _result.cancel();
+            // Nothing to do here, the constructor of std::future will take care of the cleanup
         }
 
         void SetParam(ParamType value)
@@ -106,7 +107,7 @@ class QueryCallback
         }
 
     private:
-        ACE_Future<Result> _result;
+        std::future<Result> _result;
         ParamType _param;
         uint8 _stage;
 
@@ -121,29 +122,29 @@ class QueryCallback_2
         QueryCallback_2() : _stage(chain ? 0 : CALLBACK_STAGE_INVALID) { }
 
         //! The parameter of this function should be a resultset returned from either .AsyncQuery or .AsyncPQuery
-        void SetFutureResult(ACE_Future<Result> value)
+        void SetFutureResult(std::future<Result>& value)
         {
-            _result = value;
+            _result = std::move(value);
         }
 
-        ACE_Future<Result> GetFutureResult()
+        std::future<Result>& GetFutureResult()
         {
             return _result;
         }
 
         int IsReady()
         {
-            return _result.ready();
+            return _result.wait_for(std::chrono::seconds(0)) == std::future_status::ready;
         }
 
         void GetResult(Result& res)
         {
-            _result.get(res);
+            res = _result.get();
         }
 
         void FreeResult()
         {
-            _result.cancel();
+            // Nothing to do here, the constructor of std::future will take care of the cleanup
         }
 
         void SetFirstParam(ParamType1 value)
@@ -200,7 +201,7 @@ class QueryCallback_2
         }
 
     private:
-        ACE_Future<Result> _result;
+        std::future<Result> _result;
         ParamType1 _param_1;
         ParamType2 _param_2;
         uint8 _stage;