Use boost::thread instead of std::thread

modules/game_npctrade/npctrade.lua

@@ -252,6 +252,7 @@ function getItemPrice(item, single)
   if not single then
     amount = quantityScroll:getValue()
   end
+  
   if getCurrentTradeType() == BUY then
     if buyWithBackpack:isChecked() then
       if item.ptr:isStackable() then
@@ -391,6 +392,7 @@ function refreshPlayerGoods()
 end
 
 function onOpenNpcTrade(items)
+  table.dump(items)
   tradeItems[BUY] = {}
   tradeItems[SELL] = {}
 

src/framework/core/asyncdispatcher.cpp

@@ -38,7 +38,7 @@ void AsyncDispatcher::terminate()
 void AsyncDispatcher::spawn_thread()
 {
     m_running = true;
-    m_threads.push_back(std::thread(std::bind(&AsyncDispatcher::exec_loop, this)));
+    m_threads.push_back(stdext::thread(std::bind(&AsyncDispatcher::exec_loop, this)));
 }
 
 void AsyncDispatcher::stop()
@@ -47,13 +47,13 @@ void AsyncDispatcher::stop()
     m_running = false;
     m_condition.notify_all();
     m_mutex.unlock();
-    for(std::thread& thread : m_threads)
+    for(stdext::thread& thread : m_threads)
         thread.join();
     m_threads.clear();
 };
 
 void AsyncDispatcher::exec_loop() {
-    std::unique_lock<std::mutex> lock(m_mutex);
+    stdext::unique_lock<stdext::mutex> lock(m_mutex);
     while(true) {
         while(m_tasks.size() == 0 && m_running)
             m_condition.wait(lock);

src/framework/core/asyncdispatcher.h

@@ -35,9 +35,9 @@ public:
     void stop();
 
     template<class F>
-    std::future<typename std::result_of<F()>::type> schedule(const F& task) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        auto prom = std::make_shared<std::promise<typename std::result_of<F()>::type>>();
+    stdext::future<typename std::result_of<F()>::type> schedule(const F& task) {
+        stdext::lock_guard<stdext::mutex> lock(m_mutex);
+        auto prom = std::make_shared<stdext::promise<typename std::result_of<F()>::type>>();
         m_tasks.push_back([=]() { prom->set_value(task()); });
         m_condition.notify_all();
         return prom->get_future();
@@ -48,9 +48,9 @@ protected:
 
 private:
     std::list<std::function<void()>> m_tasks;
-    std::mutex m_mutex;
-    std::list<std::thread> m_threads;
-    std::condition_variable m_condition;
+    stdext::mutex m_mutex;
+    std::list<stdext::thread> m_threads;
+    stdext::condition_variable m_condition;
     stdext::boolean<false> m_running;
 };
 

src/framework/core/logger.cpp

@@ -35,7 +35,7 @@ Logger g_logger;
 
 void Logger::log(Fw::LogLevel level, const std::string& message)
 {
-    std::lock_guard<std::recursive_mutex> lock(m_mutex);
+    stdext::lock_guard<stdext::recursive_mutex> lock(m_mutex);
 
 #ifdef NDEBUG
     if(level == Fw::LogDebug)
@@ -97,7 +97,7 @@ void Logger::log(Fw::LogLevel level, const std::string& message)
 
 void Logger::logFunc(Fw::LogLevel level, const std::string& message, std::string prettyFunction)
 {
-    std::lock_guard<std::recursive_mutex> lock(m_mutex);
+    stdext::lock_guard<stdext::recursive_mutex> lock(m_mutex);
 
     prettyFunction = prettyFunction.substr(0, prettyFunction.find_first_of('('));
     if(prettyFunction.find_last_of(' ') != std::string::npos)
@@ -118,7 +118,7 @@ void Logger::logFunc(Fw::LogLevel level, const std::string& message, std::string
 
 void Logger::fireOldMessages()
 {
-    std::lock_guard<std::recursive_mutex> lock(m_mutex);
+    stdext::lock_guard<stdext::recursive_mutex> lock(m_mutex);
 
     if(m_onLog) {
         auto backup = m_logMessages;
@@ -130,7 +130,7 @@ void Logger::fireOldMessages()
 
 void Logger::setLogFile(const std::string& file)
 {
-    std::lock_guard<std::recursive_mutex> lock(m_mutex);
+    stdext::lock_guard<stdext::recursive_mutex> lock(m_mutex);
 
     m_outFile.open(stdext::utf8_to_latin1(file.c_str()).c_str(), std::ios::out | std::ios::app);
     if(!m_outFile.is_open() || !m_outFile.good()) {

src/framework/core/logger.h

@@ -62,7 +62,7 @@ private:
     std::list<LogMessage> m_logMessages;
     OnLogCallback m_onLog;
     std::ofstream m_outFile;
-    std::recursive_mutex m_mutex;
+    stdext::recursive_mutex m_mutex;
 };
 
 extern Logger g_logger;

src/framework/sound/soundmanager.cpp

@@ -96,9 +96,9 @@ void SoundManager::poll()
 
     for(auto it = m_streamFiles.begin(); it != m_streamFiles.end();) {
         StreamSoundSourcePtr source = it->first;
-        std::future<SoundFilePtr>& future = it->second;
+        stdext::future<SoundFilePtr>& future = it->second;
 
-        if(std::is_ready(future)) {
+        if(stdext::is_ready(future)) {
             SoundFilePtr sound = future.get();
             if(sound)
                 source->setSoundFile(sound);
@@ -264,7 +264,7 @@ SoundSourcePtr SoundManager::createSoundSource(const std::string& filename)
             source = combinedSource;
 #else
             StreamSoundSourcePtr streamSource(new StreamSoundSource);
-            m_streamFiles[streamSource] = m_loadJobs [=]() -> SoundFilePtr {
+            m_streamFiles[streamSource] = g_asyncDispatcher.schedule([=]() -> SoundFilePtr {
                 try {
                     return SoundFile::loadSoundFile(filename); 
                 } catch(std::exception& e) {

src/framework/sound/soundmanager.h

@@ -25,6 +25,7 @@
 
 #include "declarations.h"
 #include "soundchannel.h"
+#include <framework/stdext/thread.h>
 
 //@bindsingleton g_sounds
 class SoundManager
@@ -57,7 +58,7 @@ private:
     ALCdevice *m_device;
     ALCcontext *m_context;
 
-    std::map<StreamSoundSourcePtr, std::future<SoundFilePtr>> m_streamFiles;
+    std::map<StreamSoundSourcePtr, stdext::future<SoundFilePtr>> m_streamFiles;
     std::unordered_map<std::string, SoundBufferPtr> m_buffers;
     std::vector<SoundSourcePtr> m_sources;
     stdext::boolean<true> m_audioEnabled;

src/framework/stdext/thread.h

@@ -24,14 +24,15 @@
 #define THREAD_H
 
 // hack to enable std::thread on mingw32 4.6
-#if !defined(_GLIBCXX_HAS_GTHREADS) && defined(__GNUG__)
+#if 1
+//#if !defined(_GLIBCXX_HAS_GTHREADS) && defined(__GNUG__)
 #include <boost/thread/thread.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/condition_variable.hpp>
-namespace std {
+namespace stdext {
     using boost::thread;
     using boost::future;
     using boost::future_status;
@@ -49,21 +50,43 @@ namespace std {
     using boost::condition_variable_any;
 
     template<typename R>
-    bool is_ready(std::future<R>& f)
+    bool is_ready(stdext::future<R>& f)
     { return f.wait_for(boost::chrono::seconds(0)) == future_status::ready; }
 }
 
 #else
+
 #include <thread>
 #include <condition_variable>
 #include <mutex>
 #include <future>
 
-namespace std {
+namespace stdext {
     template<typename R>
     bool is_ready(std::future<R>& f)
     { return f.wait_for(chrono::seconds(0)) == future_status::ready; }
 };
+namespace stdext {
+    using std::thread;
+    using std::future;
+    using std::future_status;
+    using std::promise;
+
+    using std::mutex;
+    using std::timed_mutex;
+    using std::recursive_mutex;
+    using std::recursive_timed_mutex;
+
+    using std::lock_guard;
+    using std::unique_lock;
+
+    using std::condition_variable;
+    using std::condition_variable_any;
+
+    template<typename R>
+    bool is_ready(std::future<R>& f)
+    { return f.wait_for(boost::chrono::seconds(0)) == future_status::ready; }
+}
 
 #endif