ZO_Object design question

[merlight]

I have a problem with the behaviour of ZO_Object's two methods. It's confusing at best for me. Currently I'm under the impression that it's simply copied from Programming in Lua.

ZO_Object:Subclass returns setmetatable({}, {__index = BaseClass}). The returned empty table cannot be used as a metatable itself... yet.

ZO_Object:New returns setmetatable({}, Class), and adds Class.__index = Class, so from now on the Class can be used as a metatable. Why does New, method that creates an instance, modify the class? Is there a reason to have a subclass incomplete until an instance is created?

And if you're interested what led me to this question, I want to replace the class (metatable) of an existing object with a subclass (instead of overriding several methods one by one). I never call New on the subclass, so I have to add __index myself due to the current design. It's simple, but I just can't grasp the concept why ZO_Object:Subclass() doesn't return a ready-to-use thing.

[Sasky]

Originally Posted by merlight ZO_Object:Subclass returns setmetatable({}, {__index = BaseClass}). The returned empty table cannot be used as a metatable itself... yet.

There is nothing preventing a table from being used as a metatable. It'll look at __index (and other special fields) and just ignore the other values.

What this does actually, is you first look in the table for the key. If it's not there, you look at __index for a function/table to go to. If it goes to another table, it'll first check that for the key then go to its metatable for __index and continue on down the line.

This example will go up the chain and find the field "foo" in A:

A = ZO_Object:Subclass()
B = A:Subclass()
C = B:Subclass()
 
A.foo = 1
 
d(C.foo) --Prints 1

Originally Posted by merlight ZO_Object:New returns setmetatable({}, Class), and adds Class.__index = Class, so from now on the Class can be used as a metatable. Why does New, method that creates an instance, modify the class? Is there a reason to have a subclass incomplete until an instance is created?

It's just making sure Class is suitable to use as a metatable.

Originally Posted by merlight And if you're interested what led me to this question, I want to replace the class (metatable) of an existing object with a subclass (instead of overriding several methods one by one). I never call New on the subclass, so I have to add __index myself due to the current design. It's simple, but I just can't grasp the concept why ZO_Object:Subclass() doesn't return a ready-to-use thing.

[/quote]
:New returns an instance of the object. :Subclass is intended to be a class and not a particular instance that you would then call :New to create instances of. Functionally, though, they're equivalent because Lua doesn't have a different type/method for defining a class like say Java or C.

If your object is foo, you could do something like

--Get the existing parent class for foo. This should have a __index
local mt = getmetatable(foo)
--Use that for your subclass
local Subclass = setmetatable({}, mt)
 
--Define your override functions on Subclass
function Subclass:foo() d("bar") end
--...
 
--Setup Subclass for parent of the object
setmetatable(foo, {__index = Subclass})

Alternatively, keep in mind the functions are stored on the table referenced by __index. If you define your functions on the particular instance of the object itself, they're put in the table itself rather than the metatable. This means it'll be overridden for that object and not the whole class.

[merlight]

Originally Posted by Sasky There is nothing preventing a table from being used as a metatable. It'll look at __index (and other special fields) and just ignore the other values.

Sure, but the :Subclass method doesn't put the __index field there. If you use the result as a metatable directly, it won't work. That's what I don't understand, why doesn't :Subclass create a usable metatable. I'll try to illustrate with concrete example.

-- defined in EsoUI/Ingame/Stats/Stats.lua
 
ZO_Stats = ZO_Object:Subclass()
-- ZO_Stats.__index == nil   <--- this is my complaint
 
STATS = ZO_Stats:New(control)
-- ZO_Stats.__index == ZO_Stats   <--- why the hell is it set by :New
-- getmetatable(STATS) == ZO_stats
 
-- everything fine, I can call ZO_Stats methods on STATS object
STATS:AddDivider()

Now I want to subclass ZO_Stats, and change the class of STATS object to the subclass:

MovableStats = ZO_Stats:Subclass()
setmetatable(STATS, MovableStats)
 
-- STATS is now broken, because MovableStats doesn't have __index
STATS:AddDivider() -- error: function expected instead of nil
 
-- I have to either 1) set it myself
MovableStats.__index = MovableStats
 
-- or 2) set metatable in a different way
setmetatable(STATS, {__index = MovableStats})
 
-- or 3) create a dummy object that I won't use at all
dummyStats = ZO_Object:New(MovableStats)

And the 3) point is what doesn't make any sense to me. What was the reasoning behind making :New add __index to the class, and not add it straight in :Subclass?

[Sasky]

Originally Posted by merlight And the 3) point is what doesn't make any sense to me. What was the reasoning behind making :New add __index to the class, and not add it straight in :Subclass?

Even though they are stored in the same structure in Lua, it looks like they're trying to differentiate between class (or prototype) and object. If they assume an object is always instantiated from the class then used (and not the prototype/subclass definition used directly), :New() is always called and it works fine.

PrototypeMovableStats = ZO_Stats:Subclass()
MovableStatsInstance = PrototypeMovableStats:New()

Personally, I'd probably use the alternate method I mentioned above: just define your functions directly on STATS itself. It's the same thing in effect without messing around with metatables (and is slightly more efficient).