1 files changed, 36 insertions, 36 deletions

diff --git a/src/lua/modules/thread/je_lua_thread.cpp b/src/lua/modules/thread/je_lua_thread.cpp
index ab03561..dfe45e5 100644
--- a/src/lua/modules/thread/je_lua_thread.cpp
+++ b/src/lua/modules/thread/je_lua_thread.cpp
@@ -10,11 +10,11 @@ namespace JinEngine
     namespace Lua
     {
 
-	    typedef Shared<Thread>& ThreadRef;
+	    typedef Shared<Thread>& SharedThread;
 
         int luaopen_thread(lua_State* L);
 
-        static inline ThreadRef checkThread(lua_State* L)
+        static inline SharedThread checkThread(lua_State* L)
         {
             Proxy* proxy = (Proxy*)luax_checktype(L, 1, JIN_THREAD_THREAD);
 		    return proxy->getShared<Thread>();
@@ -22,16 +22,16 @@ namespace JinEngine
 
         LUA_IMPLEMENT int threadRunner(void* t)
         {
-		    ThreadRef ref = *(Shared<Thread>*)t;
+		    SharedThread shared = *(Shared<Thread>*)t;
             lua_State* L = lua_open();
             luax_openlibs(L);
             luaopen_jin(L);
             luax_getglobal(L, MODULE_NAME);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_THREAD_THREAD, sizeof(Proxy));
-            ref.retain();
-            proxy->bind(&ref);
+            Proxy* proxy = luax_newinstance(L, JIN_THREAD_THREAD);
+            shared.retain();
+            proxy->bind(&shared);
             luax_setfield(L, -2, "_curThread");
-            luax_dostring(L, ref->code.c_str());
+            luax_dostring(L, shared->code.c_str());
             luax_close(L);
             return 0;
         }
@@ -45,66 +45,66 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_start(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            bool result = ref->start(&ref);
+		    SharedThread shared = checkThread(L);
+            bool result = shared->start(&shared);
             luax_pushboolean(L, result);
             return 1;
         }
 
         LUA_IMPLEMENT int l_wait(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            ref->wait();
+		    SharedThread shared = checkThread(L);
+            shared->wait();
             return 0;
         }
 
         LUA_IMPLEMENT int l_send(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
             const int vp = 3;
             if (luax_isnumberstrict(L, vp))
             {
                 float real = luax_checknumber(L, vp);
-                ref->send(slot, real);
+                shared->send(slot, real);
             }
             else if (luax_isbooleanstrict(L, vp))
             {
                 bool bol = luax_checkbool(L, vp);
-			    ref->send(slot, bol);
+			    shared->send(slot, bol);
             }
             else if (luax_isstringstrict(L, vp))
             {
                 const char* str = luax_checkstring(L, vp);
-			    ref->send(slot, str);
+			    shared->send(slot, str);
             }
             else if (luax_isuserdata(L, vp))
             {
                 void* p = luax_touserdata(L, vp);
-			    ref->send(slot, p);
+			    shared->send(slot, p);
             }
             else if (luax_islightuserdata(L, vp))
             {
                 void* p = luax_tolightuserdata(L, vp);
-			    ref->send(slot, p);
+			    shared->send(slot, p);
             }
             return 0;
         }
 
         LUA_IMPLEMENT int l_receive(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            bool result = ref->receive(slot);
+            bool result = shared->receive(slot);
             luax_pushboolean(L, result);
             return 1;
         }
 
         LUA_IMPLEMENT int l_fetch(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            Thread::Variant v = ref->fetch(slot);
+            Thread::Variant v = shared->fetch(slot);
             switch (v.type)
             {
             case Thread::Variant::INTERGER:
@@ -125,9 +125,9 @@ namespace JinEngine
 
             case Thread::Variant::POINTER:
                 Proxy* p = (Proxy*)v.pointer;
-                Proxy* proxy = (Proxy*)luax_newinstance(L, p->getObjectType(), sizeof(Proxy));
-                p->shared->retain();
-                proxy->bind(p->shared);
+                Proxy* proxy = luax_newinstance(L, p->getObjectType());
+                p->reference->retain();
+                proxy->bind(p->reference);
                 break;
 
             }
@@ -136,9 +136,9 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_demand(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            Thread::Variant v = ref->demand(slot);
+            Thread::Variant v = shared->demand(slot);
             switch (v.type)
             {
             case Thread::Variant::INTERGER:
@@ -160,9 +160,9 @@ namespace JinEngine
             case Thread::Variant::POINTER:
                 Proxy* p = (Proxy*)v.pointer;
                 const char* objType = p->getObjectType();
-                Proxy* proxy = (Proxy*)luax_newinstance(L, objType, sizeof(Proxy));
-                p->retain();
-                proxy->bind(p->shared);
+                Proxy* proxy = luax_newinstance(L, objType);
+                p->reference->retain();
+                proxy->bind(p->reference);
                 break;
 
             }
@@ -171,24 +171,24 @@ namespace JinEngine
 
         LUA_IMPLEMENT int l_remove(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
+		    SharedThread shared = checkThread(L);
             int slot = luax_checkinteger(L, 2);
-            ref->remove(slot);
+            shared->remove(slot);
             return 0;
         }
 
         LUA_IMPLEMENT int l_getName(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            const char* name = ref->getName();
+		    SharedThread shared = checkThread(L);
+            const char* name = shared->getName();
             luax_pushstring(L, name);
             return 1;
         }
 
         LUA_IMPLEMENT int l_isRunning(lua_State* L)
         {
-		    ThreadRef ref = checkThread(L);
-            bool running = ref->isRunning();
+		    SharedThread shared = checkThread(L);
+            bool running = shared->isRunning();
             luax_pushboolean(L, running);
             return 1;
         }
@@ -218,7 +218,7 @@ namespace JinEngine
         {
             const char* name = luax_checkstring(L, 1);
             const char* code = luax_checkstring(L, 2);
-            Proxy* proxy = (Proxy*)luax_newinstance(L, JIN_THREAD_THREAD, sizeof(Proxy));
+            Proxy* proxy = luax_newinstance(L, JIN_THREAD_THREAD);
             Thread* thread = new Thread(name, code, threadRunner);
             proxy->bind(new Shared<Thread>(thread, JIN_THREAD_THREAD));
             return 1;