Code: Select all
-- expose a constructor which can be called by <classname>(<args>)
local mt = {}
mt.__call = function(class_tbl, ...)
Code: Select all
local mt = {}
mt.__call = function(class_tbl, ...)
local obj = {}
setmetatable(obj,c)
if init then
init(obj,...)
else
-- make sure that any stuff from the base class is initialized!
if base and base.init then
base.init(obj, ...)
end
end
return obj
endCode: Select all
local mt = {}
mt.__call = function(class_tbl, ...)
local obj = {}
setmetatable(obj,c)
if init then
init(obj,...)
else
-- make sure that any stuff from the base class is initialized!
if base and base.init then
base.init(obj, ...)
end
end
return obj
endyeah I read through that part as well today.Ramcat wrote: I spent all of yesterday reading the online version of Programming in Lua which is the source reference for the class.lua you are talking about.
Lua can use two tables to represent a class. The table and a metatable that has been assigned to the table. This is one of the mechanisms that Lua uses to simulate inheritance.
The line, "local mt = {}" creates the metatable. The next line assigns a function to the metamethod __call. What I find hard to understand about this is the metamethods are "magic", I haven't found much documentation on them other than the above links. There are a bunch of metamethods that are called on the metatable of the table that is the object.
It may help to think of metamethods as a way to support standard operators on your own data structures (i.e. tables). For example, if you represented matrices with tables then you could define ‘Matrix.__add()’ so that you could write code like ‘x + y’, where those two variables are Matrix tables. This lets you avoid writing code like ‘x:add(y)’, which I think many people would find cumbersome. I hope that makes some sense and helps.Ramcat wrote:What I find hard to understand about this is the metamethods are "magic", I haven't found much documentation on them other than the above links. There are a bunch of metamethods that are called on the metatable of the table that is the object.
Code: Select all
function inherit(a, b)
-- makes a inherit eveyrhting from b
b.__index = b
setmetatble(a,b)
return a
end
Code: Select all
awesomeclass = {}
awesomeclass.text = "default text"
function awesomeclass:print()
love.graphics.print(self.text, 10, 10)
end
local obj = inherit({}, awesomeclass)
obj.text = "another text"
obj:print() -- prints "another text", would've printed "default text" without the previous line
Metatables are really just another table that explains what Lua should do if it encounters a special situations. The most common situation is a missing key from a table. If a table doesn't have a value stored at a key you ask for, it checks the metatable for an explanation of what to do. Specifically, the __index key on that metatable. If __index is a function, it runs the function. If it's another table, it goes looking for the key in that table. And if that table is missing the key, you check it's metatable. So, the chain from an object, or a table with a metatable set, goes object[key] to getmetatable(object).__index[key] to getmetatable(getmetatable(object).__index).__index[key].murks wrote:Metatables is a concept I try to grasp since quite some time, basically since I first encountered Lua, without success.
Maybe someone should write a "Metatables for dummies" book. This stuff is really confusing.
Code: Select all
Class.__index = Class