LuaTable

-- 注意：
-- 1、所有参数带hashtable的函数，将把table当做哈希表对待
-- 2、所有参数带array的函数，将把table当做可空值数组对待
-- 3、所有参数带tb的函数，对表通用，不管是哈希表还是数组

--[[数组]]
-- 计算数组长度
---@param array table
---@return number
function table.length(array)
    if array.n ~= nil then
       return array.n
    end

    local count = 0
    for i,_ in ipairs(array) do
        if count < i then
            count = i
        end
    end
    return count
end

--[[字典]]
-- 计算字典长度
---@param map table
---@return number
function table.leng(map)
    local leng = 0
    for _, _ in pairs(map) do
        leng = leng + 1
    end
    return leng;
end

-- 合并数组：将src_array数组从begin位置开始插入到dest_array数组
-- 注意：begin <= 0被认为没有指定起始位置，则将两个数组执行拼接
function table.insertto(dest_array, src_array, begin, count)
    assert(begin == nil or type(begin) == "number")
    if begin == nil or begin <= 0 then
        begin = #dest_array + 1
    end

    local src_len= 0
    if count ~= nil then
        src_len = count
    else
        src_len = #src_array
    end
    for i = 0, src_len - 1 do
        dest_array[i + begin] = src_array[i + 1]
    end
end
--向数组中插入元素
function table.insertTargetto(array,target,targetIndex)
    local newArray = {};
    if targetIndex > #array then
        array[#array + 1] = target;
        return array;
    else
        for i, v in ipairs(array) do
            if i == targetIndex then
                newArray[i] = target;
                break;
            else
                newArray[i] = array[i];
            end
        end

        for i = targetIndex, #array do
            newArray[i + 1] = array[i];
        end
        return newArray;
    end
end

-- 从数组中查找指定值，返回其索引，没找到返回false
function table.indexof(array, value, begin)
    for i = begin or 1, #array do
        if array[i] == value then
            return i
        end
    end
    return -1
end

-- 从数组中删除指定值，返回删除的值的个数
function table.removebyvalue(array, value, removeall)
    local remove_count = 0
    for i = #array, 1, -1 do
        if array[i] == value then
            table.remove(array, i)
            remove_count = remove_count + 1
            if not removeall then
                break
            end
        end
    end
    return remove_count
end
-- 删除数组中的key值
function table.removeArrayKey(array,key)
    local index = 1;
    local newTable = {}
    for i, v in ipairs(array) do
        if key ~= i then
            newTable[index] = v;
            index = index + 1;
        end
    end
    array[key] = nil;
    array = newTable;
    return newTable;
end

---[[哈希表]
---哈希表是否存在此键
---@return boolean
function table.contains(hashtable, key)
    for k, _ in pairs(hashtable) do
        if k == key then
            return true
        end
    end

    return false
end

---哈希表是否存在此值
---@return boolean
function table.containsValue(hashtable, value)
    for _, v in pairs(hashtable) do
        if v == value then
            return true
        end
    end

    return false
end

-- 从哈希表查找指定值，返回其键，没找到返回nil
function table.keyof(hashtable, value)
    if hashtable then
        for k, v in pairs(hashtable) do
            if v == value then
                return k
            end
        end

    end
    return nil
end

-- 计算哈希表长度
---count
---@param hashtable table
---@return number
function table.count(hashtable)
    local count = 0
    for k,v in pairs(hashtable) do
        if hashtable[k] ~= nil then
            count = count + 1
        end
    end
    return count
end

-- 获取哈希表所有键
---@param hashtable table
---@return table
function table.keys(hashtable)
    local keys = {}
    for k, v in pairs(hashtable) do
        keys[#keys + 1] = k
    end
    return keys
end

-- 获取哈希表所有值
---@param hashtable table
---@return table
function table.values(hashtable)
    local values = {}
    for k, v in pairs(hashtable) do
        values[#values + 1] = v
    end
    return values
end

-- 合并哈希表：将src_hashtable表合并到dest_hashtable表，相同键值执行覆盖
function table.merge(dest_hashtable, src_hashtable)
    for k, v in pairs(src_hashtable) do
        dest_hashtable[k] = v
    end
end

-- 合并哈希表：将src_hashtable表合并到dest_hashtable表，相同键值执行覆盖
function table.mergeToArray(dest_hashtable, src_hashtable, func)
    for k, v in pairs(src_hashtable) do

        if func == nil or func(v) == true then
            dest_hashtable[#dest_hashtable + 1] = v
        end
    end
end

---[[通用]]
---查找一个特定的元素
---@param tb table
---@param compare fun
function table.find(tb, compare)
    for k, v in pairs(tb) do
        if (compare(k)) then
            return v
        end
    end

    return nil
end

---清除所有
---@param tb
function table.clean(tb)
    for k, v in pairs(tb) do
        tb[k] = nil
    end
end

-- 过滤掉不符合条件的项：不对原表执行操作
function table.filter(tb, func)
    local filter = {}
    for k, v in pairs(tb) do
        if not func(k, v) then
            filter[k] = v
        end
    end
    return filter
end

-- 筛选出符合条件的项：不对原表执行操作
function table.choose(tb, func)
    local choose = {}
    for k, v in pairs(tb) do
        if func(k, v) then
            choose[k] = v
        end
    end
    return choose
end

function table.tableToArray(t, filter, p)

    local new_t= {}

    for i, v in pairs(t) do

        if filter then
            if filter(p, i, v) == true then
                new_t[#new_t + 1] = v
            end
        else
            new_t[#new_t + 1] = v
        end
    end
    return new_t
end

-- dump表
function table.dump(tb, dump_metatable, max_level)
    local lookup_table = {}
    local level = 0
    local rep = string.rep
    local dump_metatable = dump_metatable
    local max_level = max_level or 3

    local function _dump(tb, level)
        local str = "\n" .. rep("\t", level) .. "{\n"
        for k,v in pairs(tb) do
            local k_is_str = type(k) == "string" and 1 or 0
            local v_is_str = type(v) == "string" and 1 or 0
            str = str..rep("\t", level + 1).."["..rep("\"", k_is_str)..(tostring(k) or type(k))..rep("\"", k_is_str).."]".." = "
            if type(v) == "table" then
                if not lookup_table[v] and ((not max_level) or level < max_level) then
                    lookup_table[v] = true
                    str = str.._dump(v, level + 1, dump_metatable).."\n"
                else
                    str = str..(tostring(v) or type(v))..",\n"
                end
            else
                str = str..rep("\"", v_is_str)..(tostring(v) or type(v))..rep("\"", v_is_str)..",\n"
            end
        end
        if dump_metatable then
            local mt = getmetatable(tb)
            if mt ~= nil and type(mt) == "table" then
                str = str..rep("\t", level + 1).."[\"__metatable\"]".." = "
                if not lookup_table[mt] and ((not max_level) or level < max_level) then
                    lookup_table[mt] = true
                    str = str.._dump(mt, level + 1, dump_metatable).."\n"
                else
                    str = str..(tostring(v) or type(v))..",\n"
                end
            end
        end
        str = str..rep("\t", level) .. "},"
        return str
    end

    return _dump(tb, level)
end

function table.DeepCopy( obj, t )
    local InTable = t or {}
    local function Func(obj)
        if type(obj) ~= "table" then   --判断表中是否有表
            return obj;
        end
        local NewTable = {};  --定义一个新表
        InTable[obj] = NewTable;  --若表中有表，则先把表给InTable，再用NewTable去接收内嵌的表
        for k,v in pairs(obj) do  --把旧表的key和Value赋给新表
            NewTable[Func(k)] = Func(v);
        end
        return setmetatable(NewTable, getmetatable(obj))--赋值元表
    end
    return Func(obj) --若表中有表，则把内嵌的表也复制了
end