path: root/Source/external/Luax/luax_class.inc

namespace Luax
{

	//--------------------------------------------------------------------------------//

	///
	/// �Բ�ͬ���ͣ�ͨ������GetLuaClassName���������������������࣬GetClassName�ᱻ���ǣ�ָ��luax_c_getupvalue��
	///
	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::_GetClassName(lua_State* L)
	{
		LUAX_SETUP(L, "*");

		cc8* type = TYPE::GetLuaxClassName();
		state.Push(type);
		return 1;
	}

	//--------------------------------------------------------------------------------//

	///
	/// ע�Ṥ���͵������е����Ա
	/// 
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxClassShared(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetClass",     _GetClass     },
			{ "GetClassName", _GetClassName },
			{ NULL,           NULL           }
		};

		state.RegisterMethods(regTable);
	}

	///
	/// ������ij�Ա��ע����class table
	///
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxFactoryClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetRefTable", _GetRefTable },
			{ NULL,          NULL          }
		};

		state.RegisterMethods(regTable);
	}

	///
	/// ������ij�Ա��ע����class table
	///
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxSingletonClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ NULL, NULL }
		};

		state.RegisterMethods(regTable);
	}

	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::PushLuaxClassTable(LuaxState& state)
	{
		assert(mClassTable);

		mClassTable.PushRef(state);
	}

	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::SetLuaxClassTableRef(LuaxState& state, int idx)
	{
		mClassTable.SetRef(state, idx);
	}

	template<class TYPE, class BASE>
	LuaxNativeClass<TYPE, BASE>::LuaxNativeClass()
		: mWatchDog() 
#if LUAX_PROFILER 
		, mSafer(false)
#endif
	{
	}

	template<class TYPE, class BASE>
	LuaxNativeClass<TYPE, BASE>::~LuaxNativeClass()
	{
	}

#if LUAX_PROFILER
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::operator delete(void* pdead, size_t size)
	{
		if (pdead == nullptr)
			return;
		// ���ϴ�����ʵ������ʹ��Release�ͷš�
		TYPE* p = static_cast<TYPE*>(pdead);
		assert(p->mSafer);
		::operator delete(pdead, size);
	}
#endif

	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::Retain()
	{
		++mWatchDog.mNativeRef;
	}

	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::Release()
	{
		if (mWatchDog.mNativeRef > 0)
			--mWatchDog.mNativeRef;
		if (mWatchDog)
		{
#if LUAX_PROFILER
			mSafer = true;
#endif
			delete this;
		}
	}

	template<class TYPE, class BASE>
	template<typename U>
	void LuaxNativeClass<TYPE, BASE>::LuaxRetain(LuaxState& state, U* userdata)
	{
		if (PushLuaxRefTable(state))
		{
			if (userdata->PushLuaxUserdata(state))
			{
				lua_pushvalue(state, -1); // copy the userdata
				lua_gettable(state, -3); // get the count (or nil)
				u32 count = state.GetValue<u32>(-1, 0); // get the count (or 0)
				lua_pop(state, 1); // pop the old count
				lua_pushnumber(state, count + 1); // push the new count
				lua_settable(state, -3); // save it in the table: reftable[userdata] = count
			}
		}
	}

	template<class TYPE, class BASE>
	template<typename U>
	void LuaxNativeClass<TYPE, BASE>::LuaxRelease(LuaxState& state, U* userdata)
	{
		if (PushLuaxRefTable(state))
		{
			if (userdata->PushLuaxUserdata(state))
			{
				lua_pushvalue(state, -1); // copy the userdata
				lua_gettable(state, -3); // get the count (or nil)
				u32 count = state.GetValue<u32>(-1, 0); // get the count (or 0)
				lua_pop(state, 1); // pop the old count

				// no such reference
				if (count == 0)
				{
					state.Pop(2); // userdata, reftable
					return; // nothing to do
				}

				if (count > 1) {
					lua_pushnumber(state, count - 1); // push the new count
				}
				else {
					lua_pushnil(state); // maybe cause gc
				}
				lua_settable(state, -3); // save it in the table

				state.Pop(1); // reftable 
				return;
			}
			state.Pop(2); // nil, reftable
			return;
		}
	}

	template<class TYPE, class BASE>
	bool LuaxNativeClass<TYPE, BASE>::PushLuaxUserdata(LuaxState& state)
	{
		assert(!TYPE::IsLuaxClassSingleton());
		if (!mUserdata)
		{
			BindToLua(state);
			return true;
		}
		return mUserdata.PushRef(state);
	}

	template<class TYPE, class BASE>
	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberTable(LuaxState& state)
	{
		int top = state.GetTop();
		if (this->PushLuaxUserdata(state))
		{
			if (lua_getmetatable(state, -1))  // ref table 
			{
				lua_replace(state, -2);
				if (lua_getmetatable(state, -1)) // member table
				{
					lua_replace(state, -2);
					return true;
				}
			}
		}
		lua_settop(state, top);
		lua_pushnil(state);
		return false;
	}

	template<class TYPE, class BASE>
	bool LuaxNativeClass<TYPE, BASE>::PushLuaxRefTable(LuaxState& state)
	{
		// Singleton 
		if (TYPE::IsLuaxClassSingleton())
		{
			if (!this->mSingletonRefTable) {
				lua_newtable(state);
				this->mSingletonRefTable.SetRef(state, -1); // strong ref to member table won't be garbage collected
			}
			else {
				this->mSingletonRefTable.PushRef(state);
			}
			return true;
		}
		// Factory
		else 
		{
			if (this->PushLuaxUserdata(state))
			{
				if (lua_getmetatable(state, -1))
				{
					lua_replace(state, -2);
					return true;
				}
			}
		}
		return false;
	}

	///
	/// ����userdata�����Դ�����ref table��member table��class table��
	///     ref table    ��kvǿ����table�����������userdata�����ü�����ͨ��userdata��Ϊkey��
	///                  ����Ϊvalue�����Լ���Ա����
	///     member table ����lua������ʵ���ij�Ա
	///     class table  ���б����͵�ʵ�����еĺ�����
	///
	/// BindToLuaֻ���ڵ�һ��ע���Lua�����ʱ���á�
	///
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::BindToLua(LuaxState& state)
	{
		// �������ܰ�userdata
		assert(!TYPE::IsLuaxClassSingleton());
		assert(!mUserdata);

		///
		/// ����userdata������ջ����ע���ַҪת��ΪTYPE*��ֱ����this���ܻᵼ�¶��ؼ̳е���ɥʧ��̬��
		/// ���ֱ�Ӵ�this��ȥ���ڶ��ؼ̳�����£����ò�����һͷ���麯�����ġ�����������Ҫ��this
		/// ת��Ϊ��������ĵ͵�ַ�����������õ���һ��������麯������ͨ����һ������ʵ�ֶ�̬��
		///
		TYPE* p = static_cast<TYPE*>(this);
		state.PushPtrUserdata(p);

		lua_newtable(state); // ref table���޷���lua�����ʣ���������C�������������
		lua_newtable(state); // member table��lua�д����Ķ����Ա������������
		PushLuaxClassTable(state); // class table

		// stack:
		// -1: class table
		// -2: member table
		// -3: ref table
		// -4: userdata

		int top = state.GetTop();
		int memberTable = top - 1;
		int refTable = top - 2;

		// ref table ע�� __tostring �� __gc
		lua_pushcfunction(state, __tostring);
		lua_setfield(state, refTable, "__tostring");

		lua_pushcfunction(state, __gc);
		lua_setfield(state, refTable, "__gc");

		// ref table �� __index �� __newindex ��Ϊ member table
		lua_pushvalue(state, memberTable);
		lua_setfield(state, refTable, "__index");

		lua_pushvalue(state, memberTable);
		lua_setfield(state, refTable, "__newindex");

		// ����Ԫ��
		lua_setmetatable(state, -2); // class is meta of member
		lua_setmetatable(state, -2); // member is meta of ref
		lua_setmetatable(state, -2); // ref is meta of userdata

		// ����һ��userdata�������ã�����ͨ��PushLuaUserdata��������lua����
		mUserdata.SetRef(state, -1);
		assert(mUserdata);

		// ����һ����������ã���GCʱ-1
		++mWatchDog.mVMRef;
#if LUAX_PROFILER
		mRefVMs.insert(state.GetVM());
#endif
	}

	///
	/// ��Ա���ù���
	///
	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::SetLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef, int idx)
	{
		ClearLuaxMemberRef(state, memRef);
		if (!lua_isnil(state, idx))
		{
			idx = state.AbsIndex(idx);
			if (PushLuaxRefTable(state))
			{
				lua_pushvalue(state, idx);
				memRef.refID = luaL_ref(state, -2);
				state.Pop(); // ref table
			}
		}
	}

	template<class TYPE, class BASE>
	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
	{
		if (memRef)
		{
			if (PushLuaxRefTable(state))
			{
				lua_rawgeti(state, -1, memRef.refID);
				lua_replace(state, -2); // ref table
				if (lua_isnil(state, -1))
					goto failed;
				return true;
			}
		}
		lua_pushnil(state);
	failed:
		memRef.refID = LUA_NOREF;
		return false;
	}

	template<class TYPE, class BASE> 
	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberRef(LuaxState& state, int refID)
	{
		if (PushLuaxRefTable(state))
		{
			lua_rawgeti(state, -1, refID);
			lua_replace(state, -2); // ref table
			if (lua_isnil(state, -1))
				goto failed;
			return true;
		}
		lua_pushnil(state);
	failed:
		return false;
	}

	template<class TYPE, class BASE>
	void LuaxNativeClass<TYPE, BASE>::ClearLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
	{
		if (memRef)
		{
			if (PushLuaxRefTable(state))
			{
				luaL_unref(state, -1, memRef.refID);
				state.Pop(); // ref table
			}
			memRef.refID = LUA_NOREF;
		}
	}

	//--------------------------------------------------------------------------------//

	///
	/// �ͷŹ���������ʵ��
	///
	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::__gc(lua_State* L)
	{
		LUAX_STATE(L);

		TYPE* self = state.GetUserdata<TYPE>(1);
		assert(self);

#if LUAX_PROFILER 
		std::cout << "Luax: GC<" << TYPE::GetLuaxClassName() << ">\n";
#endif

		if(self->mWatchDog.mVMRef > 0)
			--self->mWatchDog.mVMRef;

		self->Release();

		return 0;
	}

	///
	/// �����ʽ����:
	/// ��ַ ����
	///
	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::__tostring(lua_State* L)
	{
		// params: 
		// 1: userdata

		LUAX_STATE(L);
		TYPE* self = state.GetUserdata<TYPE>(1);
		if (self)
		{
			cc8* classname = "";
			lua_getfield(state, 1, "GetClassName");
			if (state.IsType(-1, LUA_TFUNCTION))
			{
				lua_pushvalue(L, 1); // userdata 
				state.Call(1, 1); // �������GetClassName����
				classname = state.GetValue<cc8*>(-1, "");
			}
			else
			{
				classname = TYPE::GetLuaxClassName();
			}
			lua_pushfstring(L, "%s: %p", classname, self);
			return 1;
		}
		return 0;
	}

#if LUAX_ENABLE_NATIVE_EXTEND
	///
	/// ���������࣬��lua���������ij�Ա����Ϊ����������ƣ����DZ�֤��userdata��ͳһ��Native class�������ṩ__init֧�֣���
	/// nativeʵ�崴�������ʹ��__init���г�ʼ����������ӵ�кͻ���һ����New�����б�����native������һ�������͡�
	///
	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::_ExtendFactory(lua_State* L)
	{
		// upvalues:
		// 1: base class 

		// params: 
		// 1: class name 

		int baseClass = lua_upvalueindex(1);

		lua_newtable(L); // class table 

		int inheritClass = lua_gettop(L);

		// .GetClassName()
		cc8* type = lua_tostring(L, 1);
		lua_pushstring(L, type);
		lua_pushcclosure(L, luax_c_getupvalue, 1); 
		lua_setfield(L, -2, "GetClassName");

		// .GetClass()
		lua_pushvalue(L, inheritClass);
		lua_pushcclosure(L, luax_c_getupvalue, 1);
		lua_setfield(L, -2, "GetClass");

		// .Extend()
		lua_pushvalue(L, inheritClass);
		lua_pushcclosure(L, _ExtendFactory, 1);
		lua_setfield(L, -2, "Extend");

		// .New() 
		lua_pushvalue(L, inheritClass); 
		lua_getfield(L, baseClass, "New");
		lua_pushcclosure(L, _New, 2);
		lua_setfield(L, -2, "New");

		// __base = baseClass
		lua_pushvalue(L, baseClass);
		lua_setfield(L, -2, "__base");

		// __index = inheritClass
		lua_pushvalue(L, inheritClass);
		lua_setfield(L, -2, "__index"); 

		// metatable is baseClass
		lua_pushvalue(L, baseClass);
		lua_setmetatable(L, inheritClass);

		return 1;
	}

	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::_ExtendSingleton(lua_State* L)
	{
		// upvalues:
		// 1: base class 

		// params: 
		// 1: class name 

		int baseClass = lua_upvalueindex(1); 

		lua_newtable(L); // class name 

		int inheritClass = lua_gettop(L);

		// .GetClassName()
		cc8* type = lua_tostring(L, 1);
		lua_pushstring(L, type);
		lua_pushcclosure(L, luax_c_getupvalue, 1);
		lua_setfield(L, -2, "GetClassName");

		// .GetClass()
		lua_pushvalue(L, inheritClass);
		lua_pushcclosure(L, luax_c_getupvalue, 1);
		lua_setfield(L, -2, "GetClass");

		// .Extend()
		lua_pushvalue(L, inheritClass);
		lua_pushcclosure(L, _ExtendFactory, 1);
		lua_setfield(L, -2, "Extend");

		// __base = baseClass
		lua_pushvalue(L, baseClass);
		lua_setfield(L, -2, "__base");

		// __index = inheritClass
		lua_pushvalue(L, inheritClass);
		lua_setfield(L, -2, "__index");

		// metatable is baseClass
		lua_pushvalue(L, baseClass);
		lua_setmetatable(L, inheritClass);

		return 1;
	}
#endif /*LUAX_ENABLE_NATIVE_EXTEND*/

	template<class TYPE, class BASE> 
	int LuaxNativeClass<TYPE, BASE>::_GetClass(lua_State* L)
	{
		LUAX_STATE(L);
		if (!mClassTable)
			lua_pushnil(L);
		else
			mClassTable.PushRef(state);
		return 1;
	}

	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::_GetRefTable(lua_State* L)
	{
		LUAX_STATE(L);
		TYPE* self = state.GetUserdata<TYPE>(1);
		bool success = self->PushLuaxRefTable(state);
		if (!success)
			lua_pushnil(L);
		return 1;
	}

	template<class TYPE, class BASE>
	int LuaxNativeClass<TYPE, BASE>::_New(lua_State* L)
	{
		LUAX_STATE(L);

		// upvalues:
		// 1: class table 
		// 2: original New()

		// stack:
		// -1~-n: args

		int n = lua_gettop(L); // n args
		
		lua_pushvalue(L, lua_upvalueindex(2));
		if (state.IsType(-1, LUA_TFUNCTION))
		{
			// stack:
			// -1: New
			// -2~-1-n: args

			state.PushValues(-1 - n, n);

			// stack:
			// -1~-n: args
			// -n-1: New
			// -n-2~-1-2n: args

			state.Call(n, 1);
			
			// stack: 
			// -1: userdata 
			// -2~-1-n: args

			// reset member table's metatable to class table
			if (state.IsType(-1, LUA_TUSERDATA))
			{
				if (lua_getmetatable(L, -1)) // ref table
				{
					if (lua_getmetatable(L, -1)) // member table
					{
						lua_pushvalue(L, lua_upvalueindex(1)); // class table 
						lua_setmetatable(L, -2);
						state.Pop(); // member table
					}
					state.Pop(); // ref table
				}

				// stack: 
				// -1: userdata
				// -2~-1-n: args

				int args = state.AbsIndex(-1 - n);

				// ���Ե���__init����
				lua_getfield(L, lua_upvalueindex(1), "__init");

				if (state.IsType(-1, LUA_TFUNCTION))
				{
					lua_pushvalue(L, -2); // userdata
					state.PushValues(args, n);
					state.Call(n + 1, 0);
				}
				else
					state.Pop();

			}

			return 1;
		}
		return 0;
	}

	template<class TYPE, class BASE> LuaxStrongRef LuaxNativeClass<TYPE, BASE>::mClassTable;        // class table
	template<class TYPE, class BASE> LuaxStrongRef LuaxNativeClass<TYPE, BASE>::mSingletonRefTable; // ����

}