*shared 增加依赖

1 files changed, 64 insertions, 15 deletions

diff --git a/src/lua/common/je_lua_shared.hpp b/src/lua/common/je_lua_shared.hpp
index 876fe28..d6ea357 100644
--- a/src/lua/common/je_lua_shared.hpp
+++ b/src/lua/common/je_lua_shared.hpp
@@ -1,6 +1,9 @@
 #ifndef __JIN_COMMON_SHARED_H
 #define __JIN_COMMON_SHARED_H
 
+#include <map>
+#include <vector>
+
 namespace JinEngine
 {
     namespace Lua
@@ -11,32 +14,77 @@ namespace JinEngine
         public:
             void retain()
             {
-                ++count;
+                ++mCount;
             }
 
             void release()
             {
-                if (--count <= 0)
+                if (--mCount <= 0)
                     delete this;
             }
 
-            // Object type string.
+            // Object type.
             const char* const type;
 
-            void setUserdata(void* data)
+            void setDependency(int key, SharedBase* shared)
+            {
+                removeDependency(key);
+                shared->retain();
+                mDependencies.insert(std::pair<int, SharedBase*>(key, shared));
+            }
+
+            void removeDependency(int key)
             {
-                userdata = data;
+                if (!isDependOn(key))
+                    return;
+                DepMap::iterator it = mDependencies.find(key);
+                it->second->release();
+                mDependencies.erase(it);
             }
 
-            void* getUserdata()
+            void removeDependency(SharedBase* dep)
             {
-                return userdata;
+                for (DepMap::iterator it = mDependencies.begin(); it != mDependencies.end();)
+                {
+                    if (it->second == dep)
+                    {
+                        it->second->release();
+                        mDependencies.erase(it);
+                    }
+                    else
+                        ++it;
+                }
+            }
+
+            bool isDependOn(int key)
+            {
+                return mDependencies.find(key) != mDependencies.end();
+            }
+
+            bool isDependOn(SharedBase* shared)
+            {
+                for (std::pair<int, SharedBase*> dep : mDependencies)
+                {
+                    if (dep.second == shared)
+                        return true;
+                }
+                return false;
+            }
+
+            void clearDependencies()
+            {
+                for (std::pair<int, SharedBase*> dep : mDependencies)
+                    dep.second->release();
+                mDependencies.clear();
             }
 
         protected:
+
+            using DepMap = std::map<int, SharedBase*>;
+
             SharedBase(void* obj, const char* t)
-                : count(1)
-                , object(obj)
+                : mCount(1)
+                , mObject(obj)
                 , type(t)
             {
             }
@@ -45,11 +93,12 @@ namespace JinEngine
 
             virtual ~SharedBase()
             {
+                clearDependencies();
             }
 
-            void* object;
-            int count;
-            void* userdata;
+            void* mObject;
+            int mCount;
+            DepMap mDependencies;
         };
 
         template<class T>
@@ -63,12 +112,12 @@ namespace JinEngine
 
             T* operator->()
             {
-                return static_cast<T*>(object);
+                return static_cast<T*>(mObject);
             }
 
             T* getObject()
             {
-                return static_cast<T*>(object);
+                return static_cast<T*>(mObject);
             }
 
         private:
@@ -78,7 +127,7 @@ namespace JinEngine
             // Make shared only be able created with new.
             ~Shared()
             {
-                T* obj = static_cast<T*>(object);
+                T* obj = static_cast<T*>(mObject);
                 delete obj;
             }