Fix CSM crash (#5779)

[dragonfireclient.git] / src / script / cpp_api / s_async.h

diff --git a/src/script/cpp_api/s_async.h b/src/script/cpp_api/s_async.h
index a6459c18db35c04feb5abfda2329ee5a548da410..dbe0654e280282949b517d66777ef6f102338596 100644 (file)
--- a/src/script/cpp_api/s_async.h
+++ b/src/script/cpp_api/s_async.h
@@ -24,9 +24,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <deque>
 #include <map>
 
-#include "jthread/jthread.h"
-#include "jthread/jmutex.h"
-#include "jthread/jsemaphore.h"
+#include "threading/thread.h"
+#include "threading/mutex.h"
+#include "threading/semaphore.h"
 #include "debug.h"
 #include "lua.h"
 #include "cpp_api/s_base.h"
@@ -38,7 +38,16 @@ class AsyncEngine;
 // Declarations
 
 // Data required to queue a job
-struct LuaJobInfo {
+struct LuaJobInfo
+{
+       LuaJobInfo() :
+               serializedFunction(""),
+               serializedParams(""),
+               serializedResult(""),
+               id(0),
+               valid(false)
+       {}
+
        // Function to be called in async environment
        std::string serializedFunction;
        // Parameter to be passed to function
@@ -52,39 +61,30 @@ struct LuaJobInfo {
 };
 
 // Asynchronous working environment
-class AsyncWorkerThread : public JThread, public ScriptApiBase {
+class AsyncWorkerThread : public Thread, public ScriptApiBase {
 public:
-       /**
-        * default constructor
-        * @param pointer to job dispatcher
-        */
-       AsyncWorkerThread(AsyncEngine* jobDispatcher, unsigned int threadNum);
-
+       AsyncWorkerThread(AsyncEngine* jobDispatcher, const std::string &name);
        virtual ~AsyncWorkerThread();
 
-       void *Thread();
+       void *run();
 
 private:
        AsyncEngine *jobDispatcher;
-
-       // Thread number. Used for debug output
-       unsigned int threadnum;
-
 };
 
 // Asynchornous thread and job management
 class AsyncEngine {
        friend class AsyncWorkerThread;
+       typedef void (*StateInitializer)(lua_State *L, int top);
 public:
        AsyncEngine();
        ~AsyncEngine();
 
        /**
-        * Register function to be used within engine
-        * @param name Function name to be used within Lua environment
+        * Register function to be called on new states
         * @param func C function to be called
         */
-       bool registerFunction(const char* name, lua_CFunction func);
+       void registerStateInitializer(StateInitializer func);
 
        /**
         * Create async engine tasks and lock function registration
@@ -98,15 +98,14 @@ class AsyncEngine {
         * @param params Serialized parameters
         * @return jobid The job is queued
         */
-       unsigned int queueAsyncJob(std::string func, std::string params);
+       unsigned int queueAsyncJob(const std::string &func, const std::string &params);
 
        /**
         * Engine step to process finished jobs
         *   the engine step is one way to pass events back, PushFinishedJobs another
         * @param L The Lua stack
-        * @param errorhandler Stack index of the Lua error handler
         */
-       void step(lua_State *L, int errorhandler);
+       void step(lua_State *L);
 
        /**
         * Push a list of finished jobs onto the stack
@@ -126,7 +125,7 @@ class AsyncEngine {
         * Put a Job result back to result queue
         * @param result result of completed job
         */
-       void putJobResult(LuaJobInfo result);
+       void putJobResult(const LuaJobInfo &result);
 
        /**
         * Initialize environment with current registred functions
@@ -141,20 +140,20 @@ class AsyncEngine {
        // Variable locking the engine against further modification
        bool initDone;
 
-       // Internal store for registred functions
-       std::map<std::string, lua_CFunction> functionList;
+       // Internal store for registred state initializers
+       std::vector<StateInitializer> stateInitializers;
 
        // Internal counter to create job IDs
        unsigned int jobIdCounter;
 
        // Mutex to protect job queue
-       JMutex jobQueueMutex;
+       Mutex jobQueueMutex;
 
        // Job queue
        std::deque<LuaJobInfo> jobQueue;
 
        // Mutex to protect result queue
-       JMutex resultQueueMutex;
+       Mutex resultQueueMutex;
        // Result queue
        std::deque<LuaJobInfo> resultQueue;
 
@@ -162,7 +161,7 @@ class AsyncEngine {
        std::vector<AsyncWorkerThread*> workerThreads;
 
        // Counter semaphore for job dispatching
-       JSemaphore jobQueueCounter;
+       Semaphore jobQueueCounter;
 };
 
 #endif // CPP_API_ASYNC_EVENTS_HEADER