Modules + Metatables

[Nibelheim]

Hello all,

I've always sucked at using metatables, so I've always tried to avoid them. However, the time has come when I need to create a proper modular addon, and metatables are a necessity. After spending a good long while trying to wrap my head around these damn things, I think I broke my brain.

I've whipped up a quick test project for myself (located on GitHub here).

It works, except for the fact that my Aura module (Modules\Aura.lua) isn't instantiated. When one aura frame updates, it updates all aura frames created by that module with identical properties, whereas I need frames to update individually. I know I need to get into turning my modules into classes using metatables, but my brain doesn't work when it comes to this stuff.

Any help or hints would be appreciated

Thanks in advance, Nib.

[Phanx]

I don't see any metatable usage in the code you linked?

[Nibelheim]

Originally Posted by Phanx I don't see any metatable usage in the code you linked?

Correct. More looking for help on how to implement them at all, so that each aura frame created via the Aura.lua module exists in it's own instance and updates only itself. >.>

When making earlier attempts, I kept on referring back to this guide here (it looks like the methodology the modular addons I've looked at use) but couldn't quite understand how to implement such concepts into my little addon.

[Phanx]

Well, don't feel bad about your inability to understand that guide... after a quick glance I don't really know what it's talking about either, or what all the C code examples have with writing WoW addons. A better title for that thing might be "Introduction to Lua programming for C programmers". :/

I wouldn't bother with a metatable, unless you plan to be dynamically changing the metatable contents. Instead, I'd just add all the functions I wanted to a table:

local auraFunctions = {
    Update = function(self, ...)
        -- do something
    end,
    SetAura = function(self, aura)
        self.__aura = aura
    end,
    SetUnit = function(self, unit)
        self.__unit = unit
    end,
}

... and then copy them onto each aura icon as it's created:

function MyAddon:NewAura(unit, aura)
    local f = CreateFrame("Frame")
    f:SetSize(24, 24)
    -- etc.

    for k, v in pairs(auraFunctions) do
        f[k] = v
    end

    f:SetUnit(unit)
    f:SetAura(aura)
    f:Update()
end

[Nibelheim]

Originally Posted by Phanx I wouldn't bother with a metatable, unless you plan to be dynamically changing the metatable contents. Instead, I'd just add all the functions I wanted to a table:

Ohh, nifty idea. Thanks

[Kagura]

There's multiple ways of using metatables, but the below is one of the ways I use it and probably easiest to compare to "regular" way of OOP programming.

A working example you can find at https://github.com/Nimaear/Singulari...ster/Addon.lua

local Aura = {
    timer = nil, -- not necessary here, but is still nice to have a list of "member variables"
    static = nil,
    SetTimer = function (self, timer)
        self.timer = timer
    end,
    New = function(self, timer)
        local this = {
            timer = timer or 0 -- intialize defaults here
        } -- Creating a new "instance"
 
        setmetatable(this, {__index = self}) -- this is basically what makes it "work"
        return this
    end
}
 
 
local a1 = Aura:New()
local a2 = Aura:New()
a1:SetTimer(3)
a2:SetTimer(4)
Aura.static = 3
 
print(a1.timer, a2.timer)  -- 3 4
 
 
print(a1.static, a2.static)  -- 3 3

[Nibelheim]

Thanks all for the help Much appreciated. I shall now start work on my little project, and hopefully there won't be any kinks along the way

At least metatables make sense now. Creating a table which is of another table and falls back to table, but is not equal to table.

[ravagernl]

Just had this funky idea about a prototype constructor function. Might be helpfull in one way or another, also might have a gazillion of syntax errors

local tinsert, tremove = table.insert, table.remove
local function CreateFactory(name, meta, ftype, construct, ...)
    local active, inactive, factory, i = {}, {}, {}, 0
    function factory:retreive()
        local instance = tremove(inactive)
        if not instance then
            i = i + 1
            instance = setmetatable(CreateFrame(ftype or 'Frame', name and name..i or nil), meta)
            if construct then
                construct(instance, ...)
            end
        end
        active[instance] = true
    end
    function factory:release(instance)
        if not active[instance] then return end
        active[instance] = nil
        tinsert(inactive, instance)
    end
    return factory
end

[SDPhantom]

Metatables aren't that difficult once you get the hang of it. I would recommend reading up on the Official Lua Manual §2.8 on metatables. It defines which keys in a metatable are capable of performing which actions. Metatables allow the programmer to define how they want the associated object to act when manipulated. Everything from indexing and calling the value as a function to mathematical operations can be defined. Do note some of these "overrides" have been disabled in the WoW implementation of Lua.