path: root/Source/3rdParty/Luax/luax_class.inl

namespace Luax
{

	//----------------------------------------------------------------------------------------------------------------
	// �ӿ�

	///
	/// �Բ�ͬ���ͣ�ͨ������GetLuaClassName���������������������࣬GetClassName�ᱻ���ǣ�ָ��luax_c_getupvalue��
	///
	template<typename T>
	int LuaxClass<T>::l_GetClassName(lua_State* L)
	{
		LUAX_SETUP(L, "*");

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

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

	///
	/// ע�Ṥ���͵������е����Ա
	/// 
	template<typename T>
	void LuaxClass<T>::RegisterLuaxClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetClassName", l_GetClassName },
			{ NULL,           NULL           }
		};

		state.RegisterMethods(regTable);
	}

	///
	/// ������ij�Ա��ע����class table
	///
	template<typename T>
	void LuaxClass<T>::RegisterLuaxFactoryClass(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetInterfaceTable", l_GetInterfaceTable },
			{ NULL,                NULL                }
		};

		state.RegisterMethods(regTable);
	}

	///
	/// ����ʵ���ij�Ա��ע����interface table
	///
	template<typename T>
	void LuaxClass<T>::RegisterLuaxInterface(LuaxState& state)
	{
		luaL_Reg regTable[] = {
			{ "GetClass",    l_GetClass    },
			{ "GetRefTable", l_GetRefTable },
			{ NULL,          NULL          }
		};

		state.RegisterMethods(regTable);
	}

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

		state.RegisterMethods(regTable);
	}

	template<typename T>
	void LuaxClass<T>::PushLuaxInterfaceTable(LuaxState& state)
	{
		assert(mInterfaceTable);

		mInterfaceTable.PushRef(state);
	}

	template<typename T>
	void LuaxClass<T>::PushLuaxClassTable(LuaxState& state)
	{
		assert(mClassTable);

		mClassTable.PushRef(state);
	}

	template<typename T>
	void LuaxClass<T>::SetLuaxInterfaceTableRef(LuaxState& state, int idx)
	{
		mInterfaceTable.SetRef(state, idx);
	}

	template<typename T>
	void LuaxClass<T>::SetLuaxClassTableRef(LuaxState& state, int idx)
	{
		mClassTable.SetRef(state, idx);
	}

	template<typename T>
	LuaxClass<T>::LuaxClass()
	{
	}

	template<typename T>
	LuaxClass<T>::~LuaxClass()
	{
	}

	template<typename T>
	template<typename U>
	void LuaxClass<T>::LuaRetain(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<typename T>
	template<typename U>
	void LuaxClass<T>::LuaRelease(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

				if (count == 0) 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
			}
		}
	}

	template<typename T>
	bool LuaxClass<T>::PushLuaxUserdata(LuaxState& state)
	{
		assert(!T::IsLuaxClassSingleton());
		if (!mUserdata)
		{
			BindToLua(state);
			return true;
		}
		return mUserdata.PushRef(state);
	}

	template<typename T>
	bool LuaxClass<T>::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;
				}
			}
		}
		state.SetTop(top);
		lua_pushnil(state);
		return false;
	}

	template<typename T>
	bool LuaxClass<T>::PushLuaxRefTable(LuaxState& state)
	{
		// Singleton 
		if (T::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��interface table��
	///     ref table ��kvǿ����table�����������userdata�����ü�����ͨ��userdata��Ϊkey������Ϊvalue�����Լ���Ա����
	///     member table ����lua������ʵ���ij�Ա
	///     interface table ���б����͵�ʵ�����еij�Ա������
	///
	template<typename T>
	void LuaxClass<T>::BindToLua(LuaxState& state)
	{
		// �������ܰ�userdata
		assert(!T::IsLuaxClassSingleton());
		assert(!mUserdata);

		// ����userdata������ջ��
		state.PushPtrUserData(this);

		lua_newtable(state); // ref table���޷���lua�����ʣ���������C�������������
		lua_newtable(state); // member table��lua�д����Ķ����Ա������������
		PushLuaxInterfaceTable(state); // interface table�����member table��û�������Ա����interface table���ҡ�

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

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

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

		lua_pushcfunction(state, l___tostring);
		lua_setfield(state, refTable, "__tostring");

		// 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); // interface 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);
	}

	///
	/// ��Ա���ù���
	///
	template<typename T>
	void LuaxClass<T>::SetMemberRef(LuaxState& state, LuaxMemberRef& memRef, int idx)
	{
		ClearMemberRef(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<typename T>
	bool LuaxClass<T>::PushMemberRef(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<typename T>
	void LuaxClass<T>::ClearMemberRef(LuaxState& state, LuaxMemberRef& memRef)
	{
		if (memRef)
		{
			if (PushLuaxRefTable(state))
			{
				luaL_unref(state, -1, memRef.refID);
				state.Pop(); // ref table
			}
			memRef.refID = LUA_NOREF;
		}
	}

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

	///
	/// �ͷŹ���������ʵ��
	///
	template<typename T>
	int LuaxClass<T>::l___gc(lua_State* L)
	{
		LUAX_SETUP(L, "U");

		return 0;
	}

	///
	/// �����ʽ����:
	/// ��ַ ����
	///
	template<typename T>
	int LuaxClass<T>::l___tostring(lua_State* L)
	{
		LUAX_STATE(L);
		T* self = state.GetLuaUserdata<T>(1);
		if (self)
		{
			char buf[1024] = {0};
			const char* fmt = "%p <%s>";
			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 = T::GetLuaxClassName();
			}
			sprintf(buf, fmt, self, classname);
			lua_pushstring(L, buf);
			return 1;
		}
		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_ExtendFactory(lua_State* L)
	{


		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_ExtendSingleton(lua_State* L)
	{


		return 0;
	}

	template<typename T>
	int LuaxClass<T>::l_GetInterfaceTable(lua_State* L)
	{
		LUAX_STATE(L);
		if (!mInterfaceTable)
			lua_pushnil(L);
		else 
			mInterfaceTable.PushRef(state);
		return 1;
	}

	template<typename T> 
	int LuaxClass<T>::l_GetClass(lua_State* L)
	{
		LUAX_STATE(L);
		if (!mClassTable)
			lua_pushnil(L);
		else
			mClassTable.PushRef(state);
		return 1;
	}

	template<typename T>
	int LuaxClass<T>::l_GetRefTable(lua_State* L)
	{
		LUAX_STATE(L);
		T* self = state.GetLuaUserdata<T>(1);
		bool success = self->PushLuaxRefTable(state);
		if (!success)
			lua_pushnil(L);
		return 1;
	}

	template<typename T> LuaxStrongRef LuaxClass<T>::mInterfaceTable;    // interface table 
	template<typename T> LuaxStrongRef LuaxClass<T>::mClassTable;        // class table
	template<typename T> LuaxStrongRef LuaxClass<T>::mSingletonRefTable; // ����

}