1 files changed, 151 insertions, 0 deletions
diff --git a/src/lua/common/je_lua_shared.hpp b/src/lua/common/je_lua_shared.hpp
new file mode 100644
index 0000000..91705d1
--- /dev/null
+++ b/src/lua/common/je_lua_shared.hpp
@@ -0,0 +1,151 @@
+#ifndef __JIN_COMMON_SHARED_H__
+#define __JIN_COMMON_SHARED_H__
+
+#include <map>
+#include <vector>
+
+namespace JinEngine
+{
+    namespace Lua
+    {
+
+        class SharedBase
+        {
+        public:
+            void retain()
+            {
+                ++mCount;
+            }
+
+            void release()
+            {
+                if (--mCount <= 0)
+                    delete this;
+            }
+
+            // Object type.
+            const char* const type;
+
+            void setDependency(int key, SharedBase* shared)
+            {
+                removeDependency(key);
+                shared->retain();
+                mDependencies.insert(std::pair<int, SharedBase*>(key, shared));
+            }
+
+            void removeDependency(int key)
+            {
+                if (!isDependOn(key))
+                    return;
+                DepMap::iterator it = mDependencies.find(key);
+                it->second->release();
+                mDependencies.erase(it);
+            }
+
+            void removeDependency(SharedBase* dep)
+            {
+                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();
+            }
+
+            SharedBase* getDependency(int key)
+            {
+                if (!isDependOn(key))
+                    return nullptr;
+                return mDependencies.find(key)->second;
+            }
+
+            bool isType(const char* t)
+            {
+                return strcmp(type, t) == 0;
+            }
+
+        protected:
+
+            using DepMap = std::map<int, SharedBase*>;
+
+            SharedBase(void* obj, const char* t)
+                : mCount(0)
+                , mObject(obj)
+                , type(t)
+            {
+            }
+
+            SharedBase(const SharedBase&);
+
+            virtual ~SharedBase()
+            {
+                clearDependencies();
+            }
+
+            void* mObject;
+            int mCount;
+            DepMap mDependencies;
+        };
+
+        template<class T>
+        class Shared : public SharedBase
+        {
+        public:
+            Shared(T* obj, const char* type)
+                : SharedBase(obj, type)
+            {
+            }
+
+            T* operator->()
+            {
+                return static_cast<T*>(mObject);
+            }
+
+            T* getObject()
+            {
+                return static_cast<T*>(mObject);
+            }
+
+        private:
+            // Disable copy constructor.
+            Shared(const Shared<T>& shared);
+
+            // Make shared only be able created with new.
+            ~Shared()
+            {
+                T* obj = static_cast<T*>(mObject);
+                delete obj;
+            }
+
+        };
+
+    } // namespace Lua
+} // namespace JinEngine
+
+#endif
+\ No newline at end of file