Gammon Forum

key = { foo = bar, answer = 42 }

t = {
   [key] = "test",
   another = 43,
    }

x = { a = 1, b = 2 }

t1 = {
  m = x,
  n = x,
  }

t2 = {
  m = { a = 1, b = 2 },
  n = { a = 1, b = 2 },
  }

module "util"

function _M.deepCopyTable(t)
    return copyTable(t, "deep")
end

function _M.shallowCopyTable(t)
    return copyTable(t, "shallow")
end

function _M.copyTable(t, depth)
    assert(type(t) == "table", "You must specify a table to copy")
    assert(depth ~= nil, "You must specify either a deep or shallow copy")
    assert(depth == "deep" or depth == "shallow", "depth must be either 'deep' or 'shallow'")

    local result = {}

    for k,v in pairs(t) do
        if type(v) == "table" and depth == "deep" then
            result[k] = _M.copyTable(v,depth)
        else
            result[k] = v
        end
    end

    -- copy the metatable, if there is one
    setmetatable(result, getmetatable(t))
    
    return result
end

module "util"

function _M.deepCopyTable(t)
    return copyTable(t, "deep")
end

module "util"

function deepCopyTable(t)
    return copyTable(t, "deep")
end

module (..., package.seeall)

local copyTable  -- forward declaration

function deepCopyTable(t)
    return copyTable(t, "deep")
end

function shallowCopyTable(t)
    return copyTable(t, "shallow")
end

function copyTable(t, depth)
    assert(type(t) == "table", "You must specify a table to copy")
    assert(depth ~= nil, "You must specify either a deep or shallow copy")
    assert(depth == "deep" or depth == "shallow", "depth must be either 'deep' or 'shallow'")

    local result = {}

    for k,v in pairs(t) do
        if type(v) == "table" and depth == "deep" then
            result[k] = copyTable(v,depth)
        else
            result[k] = v
        end
    end

    -- copy the metatable, if there is one
    setmetatable(result, getmetatable(t))
    
    return result
end

module (..., package.seeall)

function deepCopyTable(t)
  assert(type(t) == "table", "You must specify a table to copy")

  local result = {}

  for k,v in pairs(t) do
    if type(v) == "table"  then
        result[k] = deepCopyTable (v)
    else
        result[k] = v
    end
  end

  -- copy the metatable, if there is one
  return setmetatable(result, getmetatable(t))

end

function shallowCopyTable(t)
assert (type(t) == "table", "You must specify a table to copy")
    
local result = {}

  for k,v in pairs(t) do
    result[k] = v
  end

  -- copy the metatable, if there is one
  return setmetatable(result, getmetatable(t))

end

require "copytable"
require "tprint"

t1 = {
  m = { a = 1, b = 2 },
  n = { a = 1, b = 2 },
  }

t2 = copytable.deepCopyTable (t1)

tprint (t2)

t2 = copytable.deep (t1)

t = copytable.deep (_G)

-- copytable.lua

--[[

Table copying functions. 

See: http://www.gammon.com.au/forum/?id=8042

Ideas by Shaun Biggs, David Haley, Nick Gammon

Date: 21st July 2007

This is intended to copy tables (make a real copy, rather than just the table
reference).

You can do a deep or shallow copy.

Shallow: Simply copies the keys and values. 
If a value is a table, you will get the same table as in the original.

Deep: Copies keys and values recursively.
If a value is a table, makes a copy of that table, and so on.

Restrictions: Items must be "safe" to copy (eg. not file IO userdata). 
If doing a deep copy, a table may not appear inside itself.

Example:

t1 = {
  m = { a = 1, b = 2 },
  n = { c = 3, d = 4 },
  }

require "copytable"  -- load this file

t2 = copytable.shallow (t1)  -- shallow copy
t3 = copytable.deep (t1)  -- copies sub tables as well

--]]

module (..., package.seeall)

function deep (t, done)
  assert (type (t) == "table", "You must specify a table to copy")

  local result = {}
  done = done or {}

  assert (not done [t], "table is defined within itself")

  done [t] = true -- we will disallow recopying table t

  for k, v in pairs (t) do
    if type (v) == "table"  then
      result [k] = deep (v, done)
    else
      result [k] = v
    end -- if table or not
  end -- for each table element

  done [t] = nil -- table t can be copied again

  -- copy the metatable
  return setmetatable (result, getmetatable (t))

end -- function deep

function shallow (t)
  assert (type (t) == "table", "You must specify a table to copy")
    
  local result = {}

  for k, v in pairs (t) do
    result [k] = v
  end -- for each table element

  -- copy the metatable
  return setmetatable (result, getmetatable (t))

end  -- function shallow

for k,v in pairs(t) do
        if type(v) == "table" and depth == "deep" then
            result[k] = copyTable(v,depth)
        else
            result[k] = v
        end
    end

for k,v in pairs(t) do
        if type(v) == "table" and depth == "deep" then
            result[k] = copyTable(v, "deep")
        else
            result[k] = v
        end
    end

<variables>
  <variable name="oldranks">oldranks = {}
  oldranks.Balaam = {}
    oldranks.Balaam.kills = "33"
    oldranks.Balaam.pups = "14726"
    oldranks.Balaam.levels = "4221"
    oldranks.Balaam.wars = "24"
    oldranks.Balaam.qp = "332067"
</variable>
</variables>

{
  Balaam = {
    levels = "4221",
    pups = "14726",
    kills = "33",
    wars = "24",
    qp = "332067",
    },
  } 

function deepcopy(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then
            return lookup_table[object]
        end  -- if
        local new_table = {}
        lookup_table[object] = new_table
        for index, value in pairs(object) do
            new_table[_copy(index)] = _copy(value)
        end  -- for
        return setmetatable(new_table, getmetatable(object))
    end  -- function _copy
    return _copy(object)
end  -- function deepcopy