--[[
-- 返回指定表格中的所有值（value）
-- example
    local t = { a = 1, b = 2, c = 3 }
    local values = table.values( t )
    -- values = { 1, 2, 3 }
    
-- @parame t 要检查的表格(t表示是table)
-- @parame table 返回指定表格的所有值，它是一个值集合的表格
--]]
function table.values( t )
    local values = {}
    for _, v in pairs( t ) do
        values[#values + 1] = v
    end
    return values
end

--[[
-- 在 目标表格 的指定位置插入 来源表格，如果没有指定位置则连接两个表格
-- example
    local tDest = { 1, 2, 3 }
    local tSrc = { 4, 5, 6 }
    table.insertTo( tDest, tSrc )
    -- tDest = { 1, 2, 3, 4, 5, 6 }
    
    tDest = { 1, 2, 3 }
    table.insertTo( tDest, tSrc, 5 )
    -- tDest = { 1, 2, 3, nil, 4, 5, 6}
    
-- @param tDest 目标表格(t表示是table)
-- @param tSrc 来源表格(t表示是table)
-- @param iBegin 插入位置(i表示是integer)
--]]
function table.insertTo( tDest, tSrc, iBegin )
    begin = checkInt( iBegin )
    if begin <= 0 then
        begin = #tDest + 1
    end
    
    local len = #tSrc
    for i = 0, len - 1 do
        tDest[i + begin] = tSrc[i+1]
    end
end

--[[
-- 在表格中查找指定值，返回其索引，查找失败则返回false
-- example
    local t = { "a", "b", "c" }
    table.indexOf( t, "b" )  -- 输出 2
    
-- @param t 表格(t表示是table)
-- @param value 要查找的值
-- @param iBegin 起始索引值(i表示是integer)
-- @return integer 返回对应的索引  如：5
--]]
function table.indexOf( t, value, iBegin )
    for i = iBegin or 1, #t do
        if t[i] == value then
            return i
        end
    end
    return false
end

--[[
-- 在表格中查找指定值，返回其key，查找失败则返回nil
-- example
    local t = { name = "a", name2 = "b", name3 = "c" }
    table.keyOf( t, "b" )  -- 输出  name3

-- @param t 表格(t表示是table)
-- @param value 要查找的值
-- @return string 返回对应的 key 如："name"
--]]
function table.keyOf( t, value )
    for k, v in pairs( t ) do
        if v == value then
            return k
        end
    end
    return nil
end

--[[
-- 从表格中删除指定值，返回删除的值的个数
-- example
    local t = { "a", "b", "c", "c" }
    table.removeByValue( t, "c", true )  -- 输出 2
     
-- @param t 表格(t表示是table)
-- @param value 要删除的值
-- @param bRemoveAll 是否删除所有相同值(b表示是booleam)
-- @return integer 返回删除的值的个数
--]]
function table.removeByValue( t, value, bRemoveAll )
    local c, i, max = 0, 1, #t
    while i <= max do
        if t[i] == value then
            table.remove( t, i )
            c = c + 1
            i = i - 1
            max = max - 1
            if not bRemoveAll then
                break
            end
        end
        i = i + 1
    end
    return c
end

--[[
-- 对表格中每一个值执行一次指定的函数，并用函数返回值更新表格内容
-- example
    local t = { name = "dualface", comp = "chukong" }
    table.map( t, function( v, k )
        -- 在每个值前后添加括号
        return "(" .. v .. ")"
    end )
    
    -- 输出修改后的表格内容
    for k, v in pairs( t ) do
        print( k, v )
    end
    
    -- 输出
    -- name (dualface)
    -- comp (chukong)
    
    fn 参数指定的函数具有两个参数，并且返回一个值。原型如下：
    function map_function(value, key)
        return value
    end
    
-- @param t (t表示是table)
-- @param fn 函数
--]]
function table.map( t, fn )
    for k, v in pairs( t ) do
        t[k] = fn( v, k )
    end
end

--[[
-- 对表格中每一个值执行一次指定的函数，但不更新表格内容
-- example
    local t = { name = "dualface", comp = "chukong" }
    table.walk( t, function( v, k )
        -- 输出每一个值
        print( v )
    end )
    
    fn 参数指定的函数具有两个参数，并且返回一个值。原型如下：
    function map_function(value, key)
    end

-- @param t 表格(t表示是table)
-- @param fn 函数
--]]
function table.walk( t, fn )
    for k, v in pairs( t ) do
        fn( v, k )
    end
end

--[[
-- 对表格中每一个值执行一次指定的函数，如果该函数返回false，则对应的值会从表格中删除
-- example
    local t = { name = "dualface", comp = "chukong" }
    table.filter( t, function( v, k )
        return v ~= "dualface"  -- 当值等于 dualface 时，过滤掉该值
    end )
    
    -- 输出过滤后的表格内容
    -- comp chukong
    
    fn 参数指定的函数具有两个参数，并且返回一个 boolean 值。原型如下：
    function map_function(value, key)
        return true or false
    end
    
-- @param t 表格(t表示是table)
-- @param fn 函数
--]]
function table.filter( t, fn )
    for k, v in pairs( t ) do
        if not fn( v, k ) then
            t[k] = nil 
        end
    end
end

--[[
-- 遍历表格，确保其中的值唯一
-- example
    local t = { "a", "a", "b", "c" }
    local n = table.unique( t )
    -- n = { "a", "b", "c" }  == 重复的 a 被过滤掉
    
-- @param t 表格(t表示是table)
-- @return table 返回 包含所有唯一值的 表格
--]]
function table.unique( t )
    local check = {}
    local n = {}
    for k, v in pairs( t ) do
        if not check[v] then
            n[k] = v
            check[v] = true
        end
    end
    return n
end