new post | browse code | authors | help | about

LuaBin 2.0

Viewing file root / lua / includes / extensions / table.lua

  1.  
  2. // Backwards compatibility
  3. tablex = table
  4.  
  5. /*---------------------------------------------------------
  6.    Name: Inherit( t, base )
  7.    Desc: Copies any missing data from base to t
  8. ---------------------------------------------------------*/
  9. function table.Inherit( t, base )
  10.  
  11.         for k, v in pairs( base ) do
  12.                 if ( t[k] == nil ) then t[k] = v end
  13.         end
  14.        
  15.         t["BaseClass"] = base
  16.        
  17.         return t
  18.  
  19. end
  20.  
  21.  
  22. /*---------------------------------------------------------
  23.     Name: Copy(t, lookup_table)
  24.     Desc: Taken straight from http://lua-users.org/wiki/PitLibTablestuff
  25.           and modified to the new Lua 5.1 code by me.
  26.           Original function by PeterPrade!
  27. ---------------------------------------------------------*/
  28. function table.Copy(t, lookup_table)
  29.         if (t == nil) then return nil end
  30.        
  31.         local copy = {}
  32.         setmetatable(copy, getmetatable(t))
  33.         for i,v in pairs(t) do
  34.                 if type(v) ~= "table" then
  35.                         copy[i] = v
  36.                 else
  37.                         lookup_table = lookup_table or {}
  38.                         lookup_table[t] = copy
  39.                         if lookup_table[v] then
  40.                                 copy[i] = lookup_table[v] -- we already copied this table. reuse the copy.
  41.                         else
  42.                                 copy[i] = table.Copy(v,lookup_table) -- not yet copied. copy it.
  43.                         end
  44.                 end
  45.         end
  46.         return copy
  47. end
  48.  
  49. /*---------------------------------------------------------
  50.     Name: Empty( tab )
  51.     Desc: Empty a table
  52. ---------------------------------------------------------*/
  53. function table.Empty( tab )
  54.  
  55.         for k, v in pairs( tab ) do
  56.                 tab[k] = nil
  57.         end
  58.  
  59. end
  60.  
  61. /*---------------------------------------------------------
  62.     Name: CopyFromTo( FROM, TO )
  63.     Desc: Make TO exactly the same as FROM - but still the same table.
  64. ---------------------------------------------------------*/
  65. function table.CopyFromTo( FROM, TO )
  66.  
  67.         // Erase values from table TO
  68.         table.Empty( TO )
  69.        
  70.         // Copy values over
  71.         table.Merge( TO, FROM )
  72.        
  73. end
  74.  
  75.  
  76. /*---------------------------------------------------------
  77.    Name: xx
  78.    Desc: xx
  79. ---------------------------------------------------------*/
  80. function table.Merge(dest, source)
  81.  
  82.         for k,v in pairs(source) do
  83.        
  84.                 if ( type(v) == 'table' && type(dest[k]) == 'table' ) then
  85.                         -- don't overwrite one table with another;
  86.                         -- instead merge them recurisvely
  87.                         table.Merge(dest[k], v)
  88.                 else
  89.                         dest[k] = v
  90.                 end
  91.         end
  92.        
  93.         return dest
  94.        
  95. end
  96.  
  97.  
  98. /*---------------------------------------------------------
  99.    Name: xx
  100.    Desc: xx
  101. ---------------------------------------------------------*/
  102. function table.HasValue( t, val )
  103.         for k,v in pairs(t) do
  104.                 if (v == val ) then return true end
  105.         end
  106.         return false
  107. end
  108.  
  109. table.InTable = HasValue
  110.  
  111.  
  112. /*---------------------------------------------------------
  113.    Name: table.Add( dest, source )
  114.    Desc: Unlike merge this adds the two tables together and discards keys.
  115. ---------------------------------------------------------*/
  116. function table.Add( dest, source )
  117.  
  118.         // At least one of them needs to be a table or this whole thing will fall on its ass
  119.         if (type(source)!='table') then return dest end
  120.        
  121.         if (type(dest)!='table') then dest = {} end
  122.  
  123.         for k,v in pairs(source) do
  124.                 table.insert( dest, v )
  125.         end
  126.        
  127.         return dest
  128. end
  129.  
  130. /*---------------------------------------------------------
  131.    Name: table.sortdesc( table )
  132.    Desc: Like Lua's default sort, but descending
  133. ---------------------------------------------------------*/
  134. function table.sortdesc( Table )
  135.  
  136.         return table.sort( Table, function(a, b) return a > b end )
  137. end
  138.  
  139. /*---------------------------------------------------------
  140.    Name: table.SortByKey( table )
  141.    Desc: Returns a table sorted numerically by Key value
  142. ---------------------------------------------------------*/
  143.  
  144. function table.SortByKey( Table, Desc )
  145.  
  146.         local temp = {}
  147.  
  148.         for key, _ in pairs(Table) do table.insert(temp, key) end
  149.         if ( Desc ) then
  150.                 table.sort(temp, function(a, b) return Table[a] < Table[b] end)
  151.         else
  152.                 table.sort(temp, function(a, b) return Table[a] > Table[b] end)
  153.         end
  154.  
  155.         return temp
  156. end
  157.  
  158. /*---------------------------------------------------------
  159.    Name: table.Count( table )
  160.    Desc: Returns the number of keys in a table
  161. ---------------------------------------------------------*/
  162.  
  163. function table.Count (t)
  164.   local i = 0
  165.   for k in pairs(t) do i = i + 1 end
  166.   return i
  167. end
  168.  
  169.  
  170. /*---------------------------------------------------------
  171.    Name: table.Random( table )
  172.    Desc: Return a random key
  173. ---------------------------------------------------------*/
  174.  
  175. function table.Random (t)
  176.  
  177.   local rk = math.random( 1, table.Count( t ) )
  178.   local i = 1
  179.   for k, v in pairs(t) do
  180.         if ( i == rk ) then return v end
  181.         i = i + 1
  182.   end
  183.  
  184. end
  185.  
  186.  
  187. /*----------------------------------------------------------------------
  188.    Name: table.IsSequential( table )
  189.    Desc: Returns true if the tables
  190.          keys are sequential
  191. -----------------------------------------------------------------------*/
  192.  
  193. function table.IsSequential(t)
  194.         local i = 1
  195.         for key, value in pairs (t) do
  196.                 if not tonumber(i) or key ~= i then return false end
  197.                 i = i + 1
  198.         end
  199.         return true
  200. end
  201.  
  202.  
  203. /*---------------------------------------------------------
  204.    Name: table.ToString( table,name,nice )
  205.    Desc: Convert a simple table to a string
  206.                 table = the table you want to convert (table)
  207.                 name  = the name of the table (string)
  208.                 nice  = whether to add line breaks and indents (bool)
  209. ---------------------------------------------------------*/
  210.  
  211. function table.ToString(t,n,nice)
  212.         local           nl,tab  = "",  ""
  213.         if nice then    nl,tab = "\n", "\t"     end
  214.  
  215.         local function MakeTable ( t, nice, indent, done)
  216.                 local str = ""
  217.                 local done = done or {}
  218.                 local indent = indent or 0
  219.                 local idt = ""
  220.                 if nice then idt = string.rep ("\t", indent) end
  221.  
  222.                 local sequential = table.IsSequential(t)
  223.  
  224.                 for key, value in pairs (t) do
  225.  
  226.                         str = str .. idt .. tab .. tab
  227.  
  228.                         if not sequential then
  229.                                 if type(key) == "number" or type(key) == "boolean" then
  230.                                         key ='['..tostring(key)..']' ..tab..'='
  231.                                 else
  232.                                         key = tostring(key) ..tab..'='
  233.                                 end
  234.                         else
  235.                                 key = ""
  236.                         end
  237.  
  238.                         if type (value) == "table" and not done [value] then
  239.  
  240.                                 done [value] = true
  241.                                 str = str .. key .. tab .. '{' .. nl
  242.                                 .. MakeTable (value, nice, indent + 1, done)
  243.                                 str = str .. idt .. tab .. tab ..tab .. tab .."},".. nl
  244.  
  245.                         else
  246.                                
  247.                                 if      type(value) == "string" then
  248.                                         value = '"'..tostring(value)..'"'
  249.                                 elseif  type(value) == "Vector" then
  250.                                         value = 'Vector('..value.x..','..value.y..','..value.z..')'
  251.                                 elseif  type(value) == "Angle" then
  252.                                         value = 'Angle('..value.pitch..','..value.yaw..','..value.roll..')'
  253.                                 else
  254.                                         value = tostring(value)
  255.                                 end
  256.                                
  257.                                 str = str .. key .. tab .. value .. ",".. nl
  258.  
  259.                         end
  260.  
  261.                 end
  262.                 return str
  263.         end
  264.         local str = ""
  265.         if n then str = n.. tab .."=" .. tab end
  266.         str = str .."{" .. nl .. MakeTable ( t, nice) .. "}"
  267.         return str
  268. end
  269.  
  270. /*---------------------------------------------------------
  271.    Name: table.Sanitise( table )
  272.    Desc: Converts a table containing vectors, angles, bools so it can be converted to and from keyvalues
  273. ---------------------------------------------------------*/
  274. function table.Sanitise( t, done )
  275.  
  276.         local done = done or {}
  277.         local tbl = {}
  278.  
  279.         for k, v in pairs ( t ) do
  280.        
  281.                 if ( type( v ) == "table" and !done[ v ] ) then
  282.  
  283.                         done[ v ] = true
  284.                         tbl[ k ] = table.Sanitise ( v, done )
  285.  
  286.                 else
  287.  
  288.                         if ( type(v) == "Vector" ) then
  289.  
  290.                                 local x, y, z = v.x, v.y, v.z
  291.                                 if y == 0 then y = nil end
  292.                                 if z == 0 then z = nil end
  293.                                 tbl[k] = { __type = "Vector", x = x, y = y, z = z }
  294.  
  295.                         elseif ( type(v) == "Angle" ) then
  296.  
  297.                                 local p,y,r = v.pitch, v.yaw, v.roll
  298.                                 if p == 0 then p = nil end
  299.                                 if y == 0 then y = nil end
  300.                                 if r == 0 then r = nil end
  301.                                 tbl[k] = { __type = "Angle", p = p, y = y, r = r }
  302.  
  303.                         elseif ( type(v) == "boolean" ) then
  304.                        
  305.                                 tbl[k] = { __type = "Bool", tostring( v ) }
  306.  
  307.                         else
  308.                        
  309.                                 tbl[k] = tostring(v)
  310.  
  311.                         end
  312.                        
  313.                        
  314.                 end
  315.                
  316.                
  317.         end
  318.        
  319.         return tbl
  320.        
  321. end
  322.  
  323.  
  324. /*---------------------------------------------------------
  325.    Name: table.DeSanitise( table )
  326.    Desc: Converts a Sanitised table back
  327. ---------------------------------------------------------*/
  328. function table.DeSanitise( t, done )
  329.  
  330.         local done = done or {}
  331.         local tbl = {}
  332.  
  333.         for k, v in pairs ( t ) do
  334.        
  335.                 if ( type( v ) == "table" and !done[ v ] ) then
  336.                
  337.                         done[ v ] = true
  338.  
  339.                         if ( v.__type ) then
  340.                        
  341.                                 if ( v.__type == "Vector" ) then
  342.                                
  343.                                         tbl[ k ] = Vector( v.x, v.y, v.z )
  344.                                
  345.                                 elseif ( v.__type == "Angle" ) then
  346.                                
  347.                                         tbl[ k ] = Angle( v.p, v.y, v.r )
  348.                                        
  349.                                 elseif ( v.__type == "Bool" ) then
  350.                                        
  351.                                         tbl[ k ] = ( v[1] == "true" )
  352.                                        
  353.                                 end
  354.                        
  355.                         else
  356.                        
  357.                                 tbl[ k ] = table.DeSanitise( v, done )
  358.                                
  359.                         end
  360.                        
  361.                 else
  362.                
  363.                         tbl[ k ] = v
  364.                        
  365.                 end
  366.                
  367.         end
  368.        
  369.         return tbl
  370.        
  371. end
  372.  
  373. function table.ForceInsert( t, v )
  374.  
  375.         if ( t == nil ) then t = {} end
  376.        
  377.         table.insert( t, v )
  378.        
  379. end
  380.  
  381.  
  382. /*---------------------------------------------------------
  383.    Name: table.SortByMember( table )
  384.    Desc: Sorts table by named member
  385. ---------------------------------------------------------*/
  386. function table.SortByMember( Table, MemberName, bAsc )
  387.  
  388.         local TableMemberSort = function( a, b, MemberName, bReverse )
  389.        
  390.                 //
  391.                 // All this error checking kind of sucks, but really is needed
  392.                 //
  393.                 if ( type(a) != "table" ) then return !bReverse end
  394.                 if ( type(b) != "table" ) then return bReverse end
  395.                 if ( !a[MemberName] ) then return !bReverse end
  396.                 if ( !b[MemberName] ) then return bReverse end
  397.        
  398.                 if ( bReverse ) then
  399.                         return a[MemberName] < b[MemberName]
  400.                 else
  401.                         return a[MemberName] > b[MemberName]
  402.                 end
  403.                
  404.         end
  405.  
  406.         table.sort( Table, function(a, b) return TableMemberSort( a, b, MemberName, bAsc or false ) end )
  407.        
  408. end
  409.  
  410.  
  411. /*---------------------------------------------------------
  412.    Name: table.LowerKeyNames( table )
  413.    Desc: Lowercase the keynames of all tables
  414. ---------------------------------------------------------*/
  415. function table.LowerKeyNames( Table )
  416.  
  417.         local OutTable = {}
  418.  
  419.         for k, v in pairs( Table ) do
  420.        
  421.                 // Recurse
  422.                 if ( type( v ) == "table" ) then
  423.                         v = table.LowerKeyNames( v )
  424.                 end
  425.                
  426.                 OutTable[ k ] = v
  427.                
  428.                 if ( type( k ) == "string" ) then
  429.        
  430.                         OutTable[ k ]  = nil
  431.                         OutTable[ string.lower( k ) ] = v
  432.                
  433.                 end            
  434.        
  435.         end
  436.        
  437.         return OutTable
  438.        
  439. end
  440.  
  441.  
  442. /*---------------------------------------------------------
  443.    Name: table.LowerKeyNames( table )
  444.    Desc: Lowercase the keynames of all tables
  445. ---------------------------------------------------------*/
  446. function table.CollapseKeyValue( Table )
  447.  
  448.         local OutTable = {}
  449.        
  450.         for k, v in pairs( Table ) do
  451.        
  452.                 local Val = v.Value
  453.        
  454.                 if ( type( Val ) == "table" ) then
  455.                         Val = table.CollapseKeyValue( Val )
  456.                 end
  457.                
  458.                 OutTable[ v.Key ] = Val
  459.        
  460.         end
  461.        
  462.         return OutTable
  463.  
  464. end
  465.  
  466. /*---------------------------------------------------------
  467.    Name: table.ClearKeys( table, bSaveKey )
  468.    Desc: Clears the keys, converting to a numbered format
  469. ---------------------------------------------------------*/
  470. function table.ClearKeys( Table, bSaveKey )
  471.  
  472.         local OutTable = {}
  473.        
  474.         for k, v in pairs( Table ) do
  475.                 if ( bSaveKey ) then
  476.                         v.__key = k
  477.                 end
  478.                 table.insert( OutTable, v )    
  479.         end
  480.        
  481.         return OutTable
  482.  
  483. end
  484.  
  485.  
  486.  
  487. local function fnPairsSorted( pTable, Index )
  488.  
  489.         if ( Index == nil ) then
  490.        
  491.                 Index = 1
  492.        
  493.         else
  494.        
  495.                 for k, v in pairs( pTable.__SortedIndex ) do
  496.                         if ( v == Index ) then
  497.                                 Index = k + 1
  498.                                 break
  499.                         end
  500.                 end
  501.                
  502.         end
  503.        
  504.         local Key = pTable.__SortedIndex[ Index ]
  505.         if ( !Key ) then
  506.                 pTable.__SortedIndex = nil
  507.                 return
  508.         end
  509.        
  510.         Index = Index + 1
  511.        
  512.         return Key, pTable[ Key ]
  513.  
  514. end
  515.  
  516. /*---------------------------------------------------------
  517.    A Pairs function
  518.  
  519.                 Sorted by TABLE KEY
  520.                
  521. ---------------------------------------------------------*/
  522. function SortedPairs( pTable, Desc )
  523.  
  524.         pTable = table.Copy( pTable )
  525.        
  526.         local SortedIndex = {}
  527.         for k, v in pairs( pTable ) do
  528.                 table.insert( SortedIndex, k )
  529.         end
  530.        
  531.         if ( Desc ) then
  532.                 table.sort( SortedIndex, function(a,b) return a>b end )
  533.         else
  534.                 table.sort( SortedIndex )
  535.         end
  536.         pTable.__SortedIndex = SortedIndex
  537.  
  538.         return fnPairsSorted, pTable, nil
  539.        
  540. end
  541.  
  542. /*---------------------------------------------------------
  543.    A Pairs function
  544.  
  545.                 Sorted by VALUE
  546.                
  547. ---------------------------------------------------------*/
  548. function SortedPairsByValue( pTable, Desc )
  549.  
  550.         pTable = table.ClearKeys( pTable )
  551.        
  552.         if ( Desc ) then
  553.                 table.sort( pTable, function(a,b) return a>b end )
  554.         else
  555.                 table.sort( pTable )
  556.         end
  557.  
  558.         return ipairs( pTable )
  559.        
  560. end
  561.  
  562. /*---------------------------------------------------------
  563.    A Pairs function
  564.  
  565.                 Sorted by Member Value (All table entries must be a table!)
  566.                
  567. ---------------------------------------------------------*/
  568. function SortedPairsByMemberValue( pTable, pValueName, Desc )
  569.  
  570.         Desc = Desc or false
  571.        
  572.         local pSortedTable = table.ClearKeys( pTable, true )
  573.        
  574.         table.SortByMember( pSortedTable, pValueName, !Desc )
  575.        
  576.         local SortedIndex = {}
  577.         for k, v in ipairs( pSortedTable ) do
  578.                 table.insert( SortedIndex, v.__key )
  579.         end
  580.        
  581.         pTable.__SortedIndex = SortedIndex
  582.  
  583.         return fnPairsSorted, pTable, nil
  584.        
  585. end
  586.  
  587. /*---------------------------------------------------------
  588.    A Pairs function            
  589. ---------------------------------------------------------*/
  590. function RandomPairs( pTable, Desc )
  591.  
  592.         local Count = table.Count( pTable )
  593.         pTable = table.Copy( pTable )
  594.        
  595.         local SortedIndex = {}
  596.         for k, v in pairs( pTable ) do
  597.                 table.insert( SortedIndex, { key = k, val = math.random( 1, 1000 ) } )
  598.         end
  599.        
  600.         if ( Desc ) then
  601.                 table.sort( SortedIndex, function(a,b) return a.val>b.val end )
  602.         else
  603.                 table.sort( SortedIndex, function(a,b) return a.val<b.val end )
  604.         end
  605.        
  606.         for k, v in pairs( SortedIndex ) do
  607.                 SortedIndex[ k ] = v.key;
  608.         end
  609.        
  610.         pTable.__SortedIndex = SortedIndex
  611.  
  612.         return fnPairsSorted, pTable, nil
  613.        
  614. end
  615.  
  616. /*---------------------------------------------------------
  617.         GetFirstKey
  618. ---------------------------------------------------------*/
  619. function table.GetFirstKey( t )
  620.  
  621.         local k, v = next( t )
  622.         return k
  623.        
  624. end
  625.  
  626. function table.GetFirstValue( t )
  627.  
  628.         local k, v = next( t )
  629.         return v
  630.        
  631. end
  632.  
  633. function table.GetLastKey( t )
  634.  
  635.         local k, v = next( t, table.Count(t) )
  636.         return k
  637.        
  638. end
  639.  
  640. function table.GetLastValue( t )
  641.  
  642.         local k, v = next( t, table.Count(t) )
  643.         return v
  644.        
  645. end
  646.  
  647. function table.FindNext( tab, val )
  648.        
  649.         local bfound = false
  650.         for k, v in pairs( tab ) do
  651.                 if ( bfound ) then return v end
  652.                 if ( val == v ) then bfound = true end
  653.         end
  654.        
  655.         return table.GetFirstValue( tab )      
  656.        
  657. end
  658.  
  659. function table.FindPrev( tab, val )
  660.        
  661.         local last = table.GetLastValue( tab )
  662.         for k, v in pairs( tab ) do
  663.                 if ( val == v ) then return last end
  664.                 last = v
  665.         end
  666.        
  667.         return last
  668.        
  669. end
  670.  
  671. function table.GetWinningKey( tab )
  672.        
  673.         local highest = -10000
  674.         local winner = nil
  675.        
  676.         for k, v in pairs( tab ) do
  677.                 if ( v > highest ) then
  678.                         winner = k
  679.                         highest = v
  680.                 end
  681.         end
  682.        
  683.         return winner
  684.        
  685. end
  686.