ClassicAPI/AddOns/!!!ClassicAPI/Util/FunctionUtil.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