Table.lua

-- Various Table Classes


-- Table
do
  Table = { }

  -- Private key to track the number of entries in the table
  local key_n = {}

  -- Metatable to make tables inherit from Table
  local metatable = {
    __index = Table,
  }

  -- Create a new table
  function Table.New(self)
    local ret = {
      [key_n] = 0,
    }
    setmetatable(ret,metatable)

    return ret
  end
  
  -- Get table size
  function Table.GetN(t)
    -- See if the table has an "n" element
    if t[key_n] == nil then
      -- If it doesn't, count until we find nil
      local i = 0
      while t[i+1] ~= nil do i=i+1 end
      t[key_n] = i
    end

    return t[key_n]
  end
  Table.Size = Table.GetN
  
  -- Set the table size
  function Table.SetN(t,size)
    -- Get the table size
    local len = Table.GetN(t)
    
    -- Check if we're reducing the size
    if size < len then
      -- Remove all elements after size
      for i=len,size+1,-1 do
        t[i]=nil
      end
    end
  
    -- Set n
    t[key_n]=size

    return t
  end
  
  -- Add an element to a table
  function Table.Insert(t,pos,item)
    -- Check if we were given 3 arguments
    if item == nil then
      -- Nope, only 2, 2nd one is the item
      item = pos
      pos = nil
    end
  
    -- Get the number of items we're adding
    local num = 1
    if type(item) == "table" and item[key_n] ~= nil then
      num = Table.GetN(item)
    end

    -- Save the number of items in t
    local tEnd = Table.GetN(t)
  
    -- Increase number of items
    t[key_n] = Table.GetN(t) + num
  
    -- Check if we have a position
    if pos == nil then
      -- Set pos to the end
      pos = tEnd + 1
    end
  
    -- Shift everything forward
    local i
    for i=t[key_n],pos+num,-1 do
      t[i]=t[i-num]
    end
  
    -- Insert the item(s)
    if type(item) == "table" and item[key_n] ~= nil then
      -- Loop through the table to be merged
      for i=1,Table.GetN(item) do
        -- Merge them in
        t[pos+i-1]=item[i]
      end
    else
      t[pos]=item
    end

    return t
  end

  -- Add an element to the end of a table
  function Table.Append(t,item)
    -- Just the same as insert without specifying position
    return Table.Insert(t,item,nil)
  end
  
  -- Remove an element from a table
  function Table.Remove(t,pos,num)
    -- Check if we have num
    if num == nil or num < 0 then
      num = 1
    elseif num == 0 then
      return
    end
  
    -- Check if the item exists
    if Table.GetN(t) < pos then
      return
    end

    -- Shift everything forward
    for i=pos,t[key_n]-num do
      t[i]=t[i+num]
      t[i+num]=nil
    end
  
    -- Remove the previous elements
    t[key_n]=t[key_n]-num

    return t
  end
  
--[[
  -- Remove elements from the table, based on a function evaluating their values
  function Table.sieveValues(t,f,reversed)
    -- Make sure we have a sieving function
    if type(f) ~= "function" then
      return t
    end

    -- Make sure reversed is a boolean
    if type(reversed) ~= "boolean" then
      reversed = false
    end

    -- Loop through each element in the table
    local i,max = 1,Table.getn(t)
    while i <= max do
      -- Check if the element should be ignored
      local ret = f(t[i])
      if type(ret) ~= "boolean" then
        ret = false
      end
      if ret ~= reversed then
        -- Element should be removed
        Table.remove(t,i)

        -- Reduce the max
        max = Table.getn(t)
      else
        -- Element should stay
        i = i + 1
      end
    end

    return t
  end
--]]

  -- Shallow copy a table (just create a new one)
  function Table.ShallowCopy(t,into,overwrite)
    local copy = into or {}

    -- Loop through all elements of the table
    for k,v in t do
      if copy[k] == nil or overwrite then
        copy[k] = v
      end
    end

    -- Set the same metatable
    local mt = getmetatable(t)
    if type(mt) == "table" then
      setmetatable(copy,mt)
    end

    return copy
  end

  -- Deep copy a table (subtables are also copied to new ones)
  do
    local function do_deep_copy(v,saved)
      if not saved[v] then
        local t = type(v)
        if t == "table" then
          -- Deep copy the table
          saved[v] = Table.DeepCopy(v,nil,nil,saved)
        else
          -- Everything else
          saved[v] = v
        end
      end
      return saved[v]
    end

    function Table.DeepCopy(t,copy,overwrite,saved)
      -- Create a saved table
      saved = saved or setmetatable({},{__mode="k",})

      -- Check if this table has already been copied
      if saved[t] then
        return saved[t]
      end

      -- Create a copy table
      local copy = copy or {}

      -- Add this table to the saved list
      saved[t] = copy

      -- Loop through all elements of the table
      for k,v in pairs(t) do
        local new_k = do_deep_copy(k,saved)

        if copy[new_k] == nil or overwrite then
          copy[new_k] = do_deep_copy(v,saved)
        end
      end

      -- Check for a metatable
      local mt = getmetatable(t)
      if type(mt) == "table" then
        local deep_mt = getmetatable(copy)
        setmetatable(copy,Table.DeepCopy(mt,deep_mt,overwrite,saved))
      end

      -- Return the copy
      return copy
    end
  end
end

-- List
do
  -- List based on code from http://www.lua.org/pil/11.4.html

  List = {}

  local metatable = {
    __index = List
  }

  function List.New()
    local ret = { first = 0, last = -1 }
    setmetatable(ret,metatable)

    return ret
  end

  function List.PushLeft (list, value)
    list.first = list.first - 1
    list[list.first] = value;
  end

  function List.PushRight (list, value)
    list.last = list.last + 1
    list[list.last] = value
  end

  function List.PopLeft (list)
    if list.first > list.last then
      return nil
    end
    local value = list[list.first]
    list[list.first] = nil         -- to allow garbage collection
    list.first = list.first + 1
    return value
  end

  function List.PopRight (list)
    if list.first > list.last then
      return nil
    end
    local value = list[list.last]
    list[list.last] = nil
    list.last = list.last - 1
    return value
  end

  function List.Clear (list)
    for i=list.first,list.last do
      list[i] = nil
    end

    list.first = 0
    list.last = -1
  end

  function List.Size (list)
    return list.last - list.first + 1
  end
end

-- Function to selectively return values from pairs based on index name
function FindPairs(t,pattern,init,plain)
  -- Get the results from pairs
  local iter,t,first = pairs(t)

  -- Return a custom function with the table and first item from pairs()
  return function(t,idx)
    -- Loop through the values from iter()
    local value
    repeat
      -- Get the next index and skill from pairs()'s iterator
      idx,value = iter(t,idx)
    -- Loop until no pairs left or an index matches the pattern
    until idx == nil or string.find(tostring(idx),pattern,init,plain) ~= nil

    -- Return the next index and value
    return idx,value
  end,t,first
end