From a16ce94158c9cf22a19c0e73dfe2e992a8302af1 Mon Sep 17 00:00:00 2001
From: chai <chaifix@163.com>
Date: Sat, 8 Dec 2018 22:05:31 +0800
Subject: =?UTF-8?q?*=E5=8E=BB=E9=99=A4shared=20template?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/lua/common/je_lua_shared.hpp | 80 +++++++++++++++++++++-------------------
 1 file changed, 42 insertions(+), 38 deletions(-)

(limited to 'src/lua/common/je_lua_shared.hpp')

diff --git a/src/lua/common/je_lua_shared.hpp b/src/lua/common/je_lua_shared.hpp
index 86ee9be..16dd943 100644
--- a/src/lua/common/je_lua_shared.hpp
+++ b/src/lua/common/je_lua_shared.hpp
@@ -5,6 +5,8 @@
 #include <vector>
 #include <functional>
 
+#include "libjin/jin.h"
+
 namespace JinEngine
 {
     namespace Lua
@@ -15,68 +17,70 @@ namespace JinEngine
         ///
         /// 线程安全的共享模板。
         ///
-        class SharedBase
+        class Shared
         {
         public:
-            bool isType(const char* t);
-
-            const char* getType();
-
-        protected:
-            friend class LuaObject;
-
-            SharedBase(void* obj, const char* t);
-
-            SharedBase(const SharedBase&);
-
-            ///
-            /// 在同一个线程的lua_State中，LuaObject和EngineObject应该是一一对应，由LuaObject(lua runtime)管理引用计数
-            /// 和回收。Engine-side引用计数是为了维护不同线程的lua_State共享同一个EngineObject。每次由LuaObject绑定一个
-            /// Shared时就增加一个引用计数，理论上在同一个线程中，一个EngineObject只能由一个LuaObject绑定，发生在new 
-            /// instance过程中，那么mCount就表明EngineObject的共享线程数。
-            ///
-            void retain();
-
-            void release();
-
-            virtual ~SharedBase();
+            Shared(Object* obj, const char* type)
+                : mCount(0)
+                , mObject(obj)
+                , mType(type)
+            {
+            }
 
-            void* mObject;
-            int mCount;
-            const char* mType;
+            Object* operator->()
+            {
+                return static_cast<Object*>(mObject);
+            }
 
-        };
+            Object* getObject()
+            {
+                return static_cast<Object*>(mObject);
+            }
 
-        template<class T>
-        class Shared : public SharedBase
-        {
-        public:
-            Shared(T* obj, const char* type)
-                : SharedBase(obj, type)
+            inline const char* getType()
             {
+                return mType;
             }
 
-            T* operator->()
+            inline bool isType(const char* t)
             {
-                return static_cast<T*>(mObject);
+                return strcmp(mType, t) == 0;
             }
 
+            template<class T>
             T* getObject()
             {
                 return static_cast<T*>(mObject);
             }
 
         private:
-            Shared(const Shared<T>& shared);
+            friend class LuaObject;
+
+            Shared(const Shared& shared);
 
+            ///
+            /// Shared只能在堆
+            ///
             ~Shared()
             {
-                T* obj = static_cast<T*>(mObject);
+                Object* obj = static_cast<Object*>(mObject);
                 delete obj;
             }
 
-        };
+            ///
+            /// 在同一个线程的lua_State中，LuaObject和EngineObject应该是一一对应，由LuaObject(lua runtime)管理引用计数
+            /// 和回收。Engine-side引用计数是为了维护不同线程的lua_State共享同一个EngineObject。每次由LuaObject绑定一个
+            /// Shared时就增加一个引用计数，理论上在同一个线程中，一个EngineObject只能由一个LuaObject绑定，发生在new 
+            /// instance过程中，那么mCount就表明EngineObject的共享线程数。
+            ///
+            void retain();
+            void release();
 
+            Object* mObject;
+            int mCount;
+            const char* mType;
+        };
+        
     } // namespace Lua
 } // namespace JinEngine
 
-- 
cgit v1.1-26-g67d0