Changes

2,304 bytes added , 3 years ago

1 revision imported

Line 1: Line 1: −

~~--[[~~

------------------------------------------------------------------------------------

−

-- TableTools --

-- --

-- This module includes a number of functions for dealing with Lua tables. --

−

-- It is a meta-module, meant to be called from other Lua modules, and should --

-- It is a meta-module, meant to be called from other Lua modules, and should not --

−

-- ~~not~~ be called directly from #invoke. --

-- be called directly from #invoke. --

------------------------------------------------------------------------------------

−

~~--]]~~

local libraryUtil = require('libraryUtil')

Line 19: Line 17:

local checkTypeMulti = libraryUtil.checkTypeMulti

−

~~--[[~~

------------------------------------------------------------------------------------

-- isPositiveInteger

Line 28: Line 25:

-- hash part of a table.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.isPositiveInteger(v)

return type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- isNan

−

-- This function returns true if the given number is a NaN value, and false

-- This function returns true if the given number is a NaN value, and false if

−

-- if not. Although it doesn't operate on tables, it is included here as it is

-- not. Although it doesn't operate on tables, it is included here as it is useful

−

-- ~~useful~~ for determining whether a value can be a valid table key. Lua will

-- for determining whether a value can be a valid table key. Lua will generate an

−

-- ~~generate an~~ error if a NaN is used as a table key.

-- error if a NaN is used as a table key.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.isNan(v)

return type(v) == 'number' and tostring(v) == '-nan'

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- shallowClone

Line 55: Line 48:

-- table will have no metatable of its own.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.shallowClone(t)

checkType('shallowClone', 1, t, 'table')

local ret = {}

for k, v in pairs(t) do

Line 64: Line 57:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- removeDuplicates

Line 72: Line 64:

-- removed, but otherwise the array order is unchanged.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.removeDuplicates(t)

checkType('removeDuplicates', 1, t, 'table')

local isNan = p.isNan

local ret, exists = {}, {}

−

for i, v in ipairs(t) do

for _, v in ipairs(t) do

if isNan(v) then

-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.

Line 86: Line 77:

exists[v] = true

end

−

end

return ret

−

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- numKeys

Line 98: Line 88:

-- keys that have non-nil values, sorted in numerical order.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.numKeys(t)

checkType('numKeys', 1, t, 'table')

local isPositiveInteger = p.isPositiveInteger

local nums = {}

−

for k~~, v~~ in pairs(t) do

for k in pairs(t) do

if isPositiveInteger(k) then

nums[#nums + 1] = k

Line 112: Line 101:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- affixNums

Line 118: Line 106:

-- This takes a table and returns an array containing the numbers of keys with the

-- specified prefix and suffix. For example, for the table

−

-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will

-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will return

−

-- ~~return~~ {1, 3, 6}.

-- {1, 3, 6}.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.affixNums(t, prefix, suffix)

checkType('affixNums', 1, t, 'table')

Line 139: Line 126:

local nums = {}

−

for k~~, v~~ in pairs(t) do

for k in pairs(t) do

−

if type(k) == 'string' then

local num = mw.ustring.match(k, pattern)

if num then

Line 151: Line 138:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- numData

−

-- Given a table with keys like ("foo1", "bar1", "foo2", "baz2"), returns a table

-- Given a table with keys like {"foo1", "bar1", "foo2", "baz2"}, returns a table

−

-- of subtables in the format

−

-- { [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} }

-- {[1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'}}.

−

-- Keys that don't end with an integer are stored in a subtable named "other".

-- Keys that don't end with an integer are stored in a subtable named "other". The

−

-- ~~The~~ compress option compresses the table so that it can be iterated over with

-- compress option compresses the table so that it can be iterated over with

-- ipairs.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.numData(t, compress)

checkType('numData', 1, t, 'table')

Line 192: Line 177:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- compressSparseArray

Line 200: Line 184:

-- ipairs.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.compressSparseArray(t)

checkType('compressSparseArray', 1, t, 'table')

Line 211: Line 194:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- sparseIpairs

Line 218: Line 200:

-- handle nil values.

------------------------------------------------------------------------------------

−

~~--]]~~

function p.sparseIpairs(t)

checkType('sparseIpairs', 1, t, 'table')

Line 235: Line 216:

end

−

~~--[[~~

------------------------------------------------------------------------------------

-- size

Line 242: Line 222:

-- but for arrays it is more efficient to use the # operator.

------------------------------------------------------------------------------------

−

~~--]]~~

−

function p.size(t)

checkType('size', 1, t, 'table')

local i = 0

−

for k in pairs(t) do

for _ in pairs(t) do

i = i + 1

end

return i

end

−

local function defaultKeySort(item1, item2)

Line 259: Line 236:

if type1 ~= type2 then

return type1 < type2

−

~~else -- This will fail with~~ table, boolean, function.

elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then

return tostring(item1) < tostring(item2)

else

return item1 < item2

end

−

------------------------------------------------------------------------------------

−

--[[

-- keysToList

−

Returns ~~a list~~ of the keys in a table, sorted using either a default

−

comparison function or a custom keySort function.

-- Returns an array of the keys in a table, sorted using either a default

−

]]

-- comparison function or a custom keySort function.

------------------------------------------------------------------------------------

function p.keysToList(t, keySort, checked)

if not checked then

checkType('keysToList', 1, t, 'table')

−

checkTypeMulti('keysToList', 2, keySort, { 'function', 'boolean', 'nil' })

checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'})

end

−

local ~~list~~ = {}

local arr = {}

local index = 1

−

for ~~key, value~~ in pairs(t) do

for k in pairs(t) do

−

~~list~~[index] = ~~key~~

arr[index] = k

index = index + 1

end

−

if keySort ~= false then

keySort = type(keySort) == 'function' and keySort or defaultKeySort

−

table.sort(arr, keySort)

−

table.sort(~~list~~, keySort)

end

−

return ~~list~~

return arr

end

−

--[[

------------------------------------------------------------------------------------

−

Iterates through a table, with the keys sorted using the keysToList function.

-- sortedPairs

−

If there are only numerical keys, sparseIpairs is probably more efficient.

−

]]

-- Iterates through a table, with the keys sorted using the keysToList function.

-- If there are only numerical keys, sparseIpairs is probably more efficient.

------------------------------------------------------------------------------------

function p.sortedPairs(t, keySort)

checkType('sortedPairs', 1, t, 'table')

checkType('sortedPairs', 2, keySort, 'function', true)

−

local ~~list~~ = p.keysToList(t, keySort, true)

local arr = p.keysToList(t, keySort, true)

−

local i = 0

−

return function()

return function ()

i = i + 1

−

local key = ~~list~~[i]

local key = arr[i]

if key ~= nil then

return key, t[key]

Line 312: Line 293:

end

−

--[[

------------------------------------------------------------------------------------

−

Returns true if all keys ~~in the table~~ are consecutive integers starting at 1.

-- isArray

−

--]]

−

function p.isArray(t)

-- Returns true if the given value is a table and all keys are consecutive

−

~~checkType~~(~~"isArray", 1, t, "~~table")

-- integers starting at 1.

−

------------------------------------------------------------------------------------

function p.isArray(v)

if type(v) ~= 'table' then

return false

end

local i = 0

−

for k, v in pairs(t) do

for _ in pairs(v) do

i = i + 1

if v[i] == nil then

return false

end

return true

end

------------------------------------------------------------------------------------

-- isArrayLike

-- Returns true if the given value is iterable and all keys are consecutive

-- integers starting at 1.

------------------------------------------------------------------------------------

function p.isArrayLike(v)

if not pcall(pairs, v) then

return false

end

local i = 0

for _ in pairs(v) do

i = i + 1

−

if t[i] == nil then

if v[i] == nil then

return false

end

Line 328: Line 333:

end

−

-- { "a", "b", "c" } -> { a = 1, b = 2, c = 3 }

------------------------------------------------------------------------------------

−

function p.invert(~~array~~)

-- invert

−

checkType("invert", 1, ~~array~~, "table")

−

-- Transposes the keys and values in an array. For example, {"a", "b", "c"} ->

-- {a = 1, b = 2, c = 3}.

------------------------------------------------------------------------------------

function p.invert(arr)

checkType("invert", 1, arr, "table")

local map = {}

−

for i, v in ipairs(~~array~~) do

for i, v in ipairs(arr) do

map[v] = i

end

−

return map

end

−

--[[

------------------------------------------------------------------------------------

−

{ "a", "b", "c" } -> { ["a"] = true, ["b"] = true, ["c"] = true }

-- listToSet

−

--]]

-- Creates a set from the array part of the table. Indexing the set by any of the

-- values of the array returns true. For example, {"a", "b", "c"} ->

-- {a = true, b = true, c = true}.

------------------------------------------------------------------------------------

function p.listToSet(t)

checkType("listToSet", 1, t, "table")

−

local set = {}

for _, item in ipairs(t) do

set[item] = true

end

−

return set

end

−

--[[

------------------------------------------------------------------------------------

−

Recursive deep copy function.

-- deepCopy

−

Preserves identities of subtables.

−

-- Recursive deep copy function. Preserves identities of subtables.

−

]]

------------------------------------------------------------------------------------

local function _deepCopy(orig, includeMetatable, already_seen)

-- Stores copies of tables indexed by the original table.

already_seen = already_seen or {}

−

local copy = already_seen[orig]

if copy ~= nil then

return copy

end

−

if type(orig) == 'table' then

copy = {}

for orig_key, orig_value in pairs(orig) do

−

copy[~~deepcopy~~(orig_key, includeMetatable, already_seen)] = ~~deepcopy~~(orig_value, includeMetatable, already_seen)

copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)

end

already_seen[orig] = copy

−

if includeMetatable then

local mt = getmetatable(orig)

if mt ~= nil then

−

local mt_copy = ~~deepcopy~~(mt, includeMetatable, already_seen)

local mt_copy = _deepCopy(mt, includeMetatable, already_seen)

setmetatable(copy, mt_copy)

already_seen[mt] = mt_copy

Line 391: Line 405:

function p.deepCopy(orig, noMetatable, already_seen)

checkType("deepCopy", 3, already_seen, "table", true)

−

return _deepCopy(orig, not noMetatable, already_seen)

end

−

--[[

------------------------------------------------------------------------------------

−

Concatenates all values in the table that are indexed by a number, in order.

-- sparseConcat

−

sparseConcat{ a, nil, c, d } => "acd"

−

sparseConcat{ nil, b, c, d } => "bcd"

-- Concatenates all values in the table that are indexed by a number, in order.

−

]]

-- sparseConcat{a, nil, c, d} => "acd"

-- sparseConcat{nil, b, c, d} => "bcd"

------------------------------------------------------------------------------------

function p.sparseConcat(t, sep, i, j)

−

local ~~list~~ = {}

local arr = {}

−

local ~~list_i~~ = 0

local arr_i = 0

for _, v in p.sparseIpairs(t) do

−

~~list_i~~ = ~~list_i~~ + 1

arr_i = arr_i + 1

−

~~list~~[~~list_i~~] = v

arr[arr_i] = v

end

−

return table.concat(~~list~~, sep, i, j)

return table.concat(arr, sep, i, j)

end

−

--[[

------------------------------------------------------------------------------------

−

-- Finds the length of an array, or of a quasi-array with keys such

-- length

−

-- as "data1", "data2", etc., using an exponential search algorithm.

−

-- It is similar to the operator #, but may return

-- Finds the length of an array, or of a quasi-array with keys such as "data1",

−

-- a different value when there are gaps in the array portion of the table.

-- "data2", etc., using an exponential search algorithm. It is similar to the

−

-- Intended to be used on data loaded with mw.loadData. For other tables, use #.

-- operator #, but may return a different value when there are gaps in the array

−

-- Note: #frame.args in frame object always be set to 0, regardless of

-- portion of the table. Intended to be used on data loaded with mw.loadData. For

−

-- ~~the number~~ of unnamed template parameters, so use this function for

-- other tables, use #.

−

-- frame.args.

-- Note: #frame.args in frame object always be set to 0, regardless of the number

−

--]]

-- of unnamed template parameters, so use this function for frame.args.

−

------------------------------------------------------------------------------------

function p.length(t, prefix)

−

-- requiring module inline so that [[Module:Exponential search]]

-- requiring module inline so that [[Module:Exponential search]] which is

−

-- ~~which is~~ only needed by this one function

-- only needed by this one function doesn't get millions of transclusions

−

-- doesn't get millions of transclusions

local expSearch = require("Module:Exponential search")

checkType('length', 1, t, 'table')

checkType('length', 2, prefix, 'string', true)

−

return expSearch(function(i)

return expSearch(function (i)

local key

if prefix then

Line 440: Line 454:

end) or 0

end

------------------------------------------------------------------------------------

-- inArray

-- Returns true if valueToFind is a member of the array, and false otherwise.

------------------------------------------------------------------------------------

function p.inArray(arr, valueToFind)

checkType("inArray", 1, arr, "table")

−

-- if valueToFind is nil, error?

−

for _, v in ipairs(arr) do

if v == valueToFind then

Line 450: Line 469:

end

−

return false

end

return p

Kg7qin

ASL-Corp members, Bureaucrats, Check users, Structured Discussions bots, oversight, Suppressors, Administrators, Upload Wizard campaign editors

1,714

edits

Retrieved from "http://wiki.pttlink.org/wiki/Special:MobileDiff/4501...11199"

Changes

Module:TableTools (view source)

Revision as of 07:59, 24 January 2022

Navigation menu

Search