Lua: methods and properties when exporting a class from c

Question

I use lua as a scripting language for my 3d engine. I have “classes” for several objects, and now I want to use properties instead of getters and setters. So, instead of something like this

local oldState = ui:GetChild("Panel1"):GetVisible() ui:GetChild("Panel1"):SetVisible(not oldState) 

I would just

 ui.Panel1.visible = not ui.Panel1.visible 

The problem is that my C ++ code overrides the __index method to create metadata and instanced. Here it is by the way:

• Create a metathe:

   void CLUAScript::RegisterClass(const luaL_Reg funcs[], std::string const& className) { luaL_newmetatable(m_lua_state, std::string("Classes." + className).c_str()); luaL_newlib( m_lua_state, funcs); lua_setglobal(m_lua_state, className.c_str()); } 

• Create an instance of the class (the lua object contains only a pointer to the actual data stored in the C ++ code):

   int CLUAScript::NewInstanceClass(void* instance, std::string const& className) { if (!instance) { lua_pushnil(m_lua_state); return 1; } luaL_checktype(m_lua_state, 1, LUA_TTABLE); lua_newtable(m_lua_state); lua_pushvalue(m_lua_state,1); lua_setmetatable(m_lua_state, -2); lua_pushvalue(m_lua_state,1); lua_setfield(m_lua_state, 1, "__index"); void **s = (void **)lua_newuserdata(m_lua_state, sizeof(void *)); *s = instance; luaL_getmetatable(m_lua_state, std::string("Classes." + className).c_str()); lua_setmetatable(m_lua_state, -2); lua_setfield(m_lua_state, -2, "__self"); return 1; } 

The question is how can I use both methods and properties. If I just add an __index array to CLUAScript::RegisterClass funcs, it is never called. And I cannot imagine how to remove its override in CLUAScript::NewInstanceClass .

If this code is not enough, here are links to files that work with lua: the lua support class , functions for the user interface , functions for objects, and testing the lua script

Answer 1

The question is how can I use both methods and properties.

In a broad sense, methods are simply properties that are solved for functions.

If I just add __index to the funset RegisterClass array, it is never called.

This is a real problem, isn't it? The rest of your message is distracted from the real problem.

According to the docs, luaL_newlib creates a new table . So luaL_newmetatable. You create two tables in RegisterClass, which makes no sense. You only need to create the meta meta, and it is the meta meta that you need to add the __index and __newindex .

You cannot have __index just specify the funcs table (a shortcut for implementing class methods), and not if you want to manually march data to and from C ++ class instance properties. This should be a function that distinguishes access to the method (the value refers to the scope of the class) and access to properties (the value comes from the scope of the instance).

---

Here is an example of how your method / property access will work in Lua. The specifics are different using API C, but the approach will be the same:

 -- This is the metatable you create in RegisterClass for the C++ class 'Foo' Foo = { } -- This is pretty close to how your __index metamethod would work in the C++ code, -- except you're going to have to write code that resolves which field on the C++ object -- corresponds to 'key', if any, and push that onto the stack. function Foo.__index(instance,key) local method = rawget(Foo,key) if method then return method end return instance.properties[key] end -- This is pretty close, too, except that if you want users to be able to add properties to the Lua object -- that coexist with the C++ object properties, you'll need to write the value to the right place. function Foo.__newindex(instance,key,value) instance.properties[key] = value end -- this doesn't have to be a method on the metatable function Foo:new(state) return setmetatable({ properties = state}, self) end -- example of a class method function Foo:dump() print('dump:', self.x, self.y) end -- simulation of the userdata, an instance of your C++ class cppClassInstance = { x = 10, y = 20, } obj = Foo:new(cppClassInstance) print(obj.x) -- read `x`, which is resolved to cppClassInstance.x obj.x = 5150 -- write to 'x', which writes to cppClassInstance.x print(obj.x) -- witness our change obj:dump() -- call a class method