X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fscript%2Fcpp_api%2Fs_async.h;h=94b55db6e5a23cf2f72f0176671a043cdc7bd944;hb=3caad3f3c9e319ca67d63231e8c64b2ace855fff;hp=c5c0e091daaf99fd334e10159d20dc47e4fb22ae;hpb=6ab3b4c83856b5c8a1a526c0e4dc55babe79d50d;p=dragonfireclient.git

diff --git a/src/script/cpp_api/s_async.h b/src/script/cpp_api/s_async.h
index c5c0e091d..94b55db6e 100644
--- a/src/script/cpp_api/s_async.h
+++ b/src/script/cpp_api/s_async.h
@@ -17,15 +17,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef L_ASYNC_EVENTS_H_
-#define L_ASYNC_EVENTS_H_
+#ifndef CPP_API_ASYNC_EVENTS_HEADER
+#define CPP_API_ASYNC_EVENTS_HEADER
 
 #include <vector>
+#include <deque>
 #include <map>
 
-#include "jthread/jthread.h"
-#include "jthread/jmutex.h"
-#include "jthread/jsemaphore.h"
+#include "threading/thread.h"
+#include "threading/semaphore.h"
 #include "debug.h"
 #include "lua.h"
 #include "cpp_api/s_base.h"
@@ -37,81 +37,74 @@ class AsyncEngine;
 // Declarations
 
 // Data required to queue a job
-struct LuaJobInfo {
+struct LuaJobInfo
+{
+	LuaJobInfo() {};
+
 	// Function to be called in async environment
-	std::string serializedFunction;
+	std::string serializedFunction = "";
 	// Parameter to be passed to function
-	std::string serializedParams;
+	std::string serializedParams = "";
 	// Result of function call
-	std::string serializedResult;
+	std::string serializedResult = "";
 	// JobID used to identify a job and match it to callback
-	unsigned int JobId;
+	unsigned int id = 0;
 
-	bool valid;
+	bool valid = false;
 };
 
 // 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* m_JobDispatcher;
-
-	// Thread number. Used for debug output
-	unsigned int m_threadnum;
-
+	AsyncEngine *jobDispatcher = nullptr;
 };
 
 // Asynchornous thread and job management
 class AsyncEngine {
 	friend class AsyncWorkerThread;
+	typedef void (*StateInitializer)(lua_State *L, int top);
 public:
-	AsyncEngine();
+	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
 	 * @param numEngines Number of async threads to be started
 	 */
-	void Initialize(unsigned int numEngines);
+	void initialize(unsigned int numEngines);
 
 	/**
-	 * queue/run a async job
+	 * Queue an async job
 	 * @param func Serialized lua function
 	 * @param params Serialized parameters
 	 * @return jobid The job is queued
 	 */
-	unsigned int doAsyncJob(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
 	 * @param L The Lua stack
 	 */
-	void PushFinishedJobs(lua_State *L);
+	void pushFinishedJobs(lua_State *L);
 
 protected:
 	/**
@@ -125,7 +118,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
@@ -134,38 +127,34 @@ class AsyncEngine {
 	 * @param L Lua stack to initialize
 	 * @param top Stack position
 	 */
-	void PrepareEnvironment(lua_State* L, int top);
+	void prepareEnvironment(lua_State* L, int top);
 
 private:
+	// Variable locking the engine against further modification
+	bool initDone = false;
 
-	// Stack index of error handler
-	int m_errorhandler;
-
-	// variable locking the engine against further modification
-	bool m_initDone;
-
-	// Internal store for registred functions
-	std::map<std::string, lua_CFunction> m_FunctionList;
+	// Internal store for registred state initializers
+	std::vector<StateInitializer> stateInitializers;
 
 	// Internal counter to create job IDs
-	unsigned int m_JobIdCounter;
+	unsigned int jobIdCounter = 0;
 
 	// Mutex to protect job queue
-	JMutex m_JobQueueMutex;
+	std::mutex jobQueueMutex;
 
 	// Job queue
-	std::vector<LuaJobInfo> m_JobQueue;
+	std::deque<LuaJobInfo> jobQueue;
 
 	// Mutex to protect result queue
-	JMutex m_ResultQueueMutex;
+	std::mutex resultQueueMutex;
 	// Result queue
-	std::vector<LuaJobInfo> m_ResultQueue;
+	std::deque<LuaJobInfo> resultQueue;
 
 	// List of current worker threads
-	std::vector<AsyncWorkerThread*> m_WorkerThreads;
+	std::vector<AsyncWorkerThread*> workerThreads;
 
 	// Counter semaphore for job dispatching
-	JSemaphore m_JobQueueCounter;
+	Semaphore jobQueueCounter;
 };
 
-#endif // L_ASYNC_EVENTS_H_
+#endif // CPP_API_ASYNC_EVENTS_HEADER