Files
ClassicAPI/src/embed/AddOns/!!!ClassicAPI/Util/FunctionUtil.lua
T
Brues 1f3ce9229d refactor: move the embedded addons into src/embed/AddOns
Users saw AddOns/!!!ClassicAPI at the repository root and downloaded it,
thinking the mod is only an addon. The addons are source code for the
DLL, so they now live next to the resource loader in src/embed/. The
README says that the DLL contains them and that the folder is not for
copying into the game.

Remove the AoELootTest dev addon.
2026-10-27 16:44:30 -05:00

176 lines
5.4 KiB
Lua

-- Backport of FunctionUtil.lua to vanilla 1.12 / Lua 5.0.
--
-- Implementation differences from the modern source:
-- - Lua 5.0 has no select() and no `...` as expression; use the
-- implicit `arg` table (arg.n + arg[i]). unpack(arg) already spans
-- arg[1..arg.n] via getn — this build's unpack ignores explicit i/j
-- args, so the count must live in the table's `.n`.
-- - Lua 5.0 has no `#` operator; use table.getn().
-- - 5.0's xpcall is strictly (f, handler) — no trailing args. We wrap
-- the script call in a local closure that captures frame + arg.
-- - CallErrorHandler isn't in 1.12; we route through geterrorhandler()
-- (same pattern as ItemUtil.lua).
-- - `nop` and `assertsafe` aren't globals in stock 1.12; defined as
-- local fallbacks so this file stays self-contained.
local function nop() end
local function CallErrorHandler(err)
local h = geterrorhandler and geterrorhandler()
if h then return h(err) end
end
-- Match the modern assertsafe semantics: only fires when `condition` is
-- falsy. Calls with just a message string are no-ops (the message ends
-- up as the condition and is truthy) — matches Blizzard's source.
local function assertsafe(condition, msg)
if not condition then
CallErrorHandler(msg or "assertion failed!")
end
end
function ExecuteFrameScript(frame, scriptName, ...)
local script = frame:GetScript(scriptName);
if script then
local args = arg;
local function invoke()
return script(frame, unpack(args));
end
xpcall(invoke, CallErrorHandler);
end
end
function CallMethodOnNearestAncestor(self, methodName, ...)
local ancestor = self:GetParent();
while ancestor and not ancestor[methodName] do
ancestor = ancestor:GetParent();
end
if ancestor then
return true, ancestor[methodName](ancestor, unpack(arg));
end
return false;
end
function GetValueOrCallFunction(tbl, key, ...)
if not tbl then
return;
end
local value = tbl[key];
if type(value) == "function" then
return value(unpack(arg));
else
return value;
end
end
local function CompositeIterator(iteratorCallbackArray)
local count = table.getn(iteratorCallbackArray);
if count == 0 then
return nop;
end
local iteratorIndex = 1;
local currentIterator, currentTable, iteratorKey = iteratorCallbackArray[1]();
local function AdvanceIterators()
if currentIterator == nil then
return nil;
end
local nextKey = currentIterator(currentTable, iteratorKey);
if nextKey ~= nil then
iteratorKey = nextKey;
return nextKey;
end
if iteratorIndex < count then
iteratorIndex = iteratorIndex + 1;
currentIterator, currentTable, iteratorKey = iteratorCallbackArray[iteratorIndex]();
return AdvanceIterators();
end
currentIterator = nil;
return nil;
end
return AdvanceIterators;
end
function IteratePools(...)
local callbackArray = {};
for i = 1, arg.n do
local pool = arg[i];
table.insert(callbackArray, GenerateClosure(pool.EnumerateActive, pool));
end
return CompositeIterator(callbackArray);
end
function IterateTables(iteratorFunction, ...)
local callbackArray = {};
for i = 1, arg.n do
local tbl = arg[i];
table.insert(callbackArray, GenerateClosure(iteratorFunction, tbl));
end
return CompositeIterator(callbackArray);
end
local s_passThroughClosureGenerators = {
function(f) return function(...) return f(unpack(arg)); end; end,
function(f, a) return function(...) return f(a, unpack(arg)); end; end,
function(f, a, b) return function(...) return f(a, b, unpack(arg)); end; end,
function(f, a, b, c) return function(...) return f(a, b, c, unpack(arg)); end; end,
function(f, a, b, c, d) return function(...) return f(a, b, c, d, unpack(arg)); end; end,
function(f, a, b, c, d, e) return function(...) return f(a, b, c, d, e, unpack(arg)); end; end,
};
local s_flatClosureGenerators = {
function(f) return function() return f(); end; end,
function(f, a) return function() return f(a); end; end,
function(f, a, b) return function() return f(a, b); end; end,
function(f, a, b, c) return function() return f(a, b, c); end; end,
function(f, a, b, c, d) return function() return f(a, b, c, d); end; end,
function(f, a, b, c, d, e) return function() return f(a, b, c, d, e); end; end,
};
local function GenerateClosureInternal(generatorArray, f, ...)
local count = arg.n;
local generator = generatorArray[count + 1];
if generator then
return generator(f, unpack(arg));
end
assertsafe(false, "Closure generation does not support more than " .. (table.getn(generatorArray) - 1) .. " parameters");
return nil;
end
-- Syntactic sugar for function(...) return f(a, b, c, ...); end
function GenerateClosure(f, ...)
return GenerateClosureInternal(s_passThroughClosureGenerators, f, unpack(arg));
end
-- Generates a closure with the specified arguments that will ignore extra arguments when called later. Useful for passing
-- through callbacks to APIs where we don't want extra arguments to be passed through, i.e. simple OnClick scripts.
-- This is equivalent to: function() return f(a, b, c); end INSTEAD OF function(...) return f(a, b, c, ...); end
function GenerateFlatClosure(f, ...)
return GenerateClosureInternal(s_flatClosureGenerators, f, unpack(arg));
end
function RunNextFrame(callback)
C_Timer.After(0, callback);
end
FunctionUtil = {};
function FunctionUtil.SafeInvokeMethod(table, methodName, ...)
local method = table[methodName];
if method then
return method(table, unpack(arg));
end
return nil;
end