Shared

table.focusedArray

Function to filter indexes in an array of tables with common value(s)

function HRLib.table.focusedArray(
    array: table<string, any>[],
    focus: table<string, any>,
    cb: fun(i: integer, curr: any)?
)

Parameters description

• array - the array to filter the indexes from

• focus - the table that includes the filter values

• cb - the function that is being triggered when a match is found

Example

local array = {
    {
        ownerName = 'player_1',
        cashBalance = 2500
    },
    {
        ownerName = 'player_2',
        cashBalance = 6000
    },
    {
        ownerName = 'player_1',
        cashBalance = 1050
    }
}

HRLib.table.focusedArray(array, { ownerName = 'player_1' }, function(_, curr)
    print(curr.cashBalance)
end) -- the output is two printed values, 2500 and 1050

table.focusedHash

Function to filter keys in a hash table of arrays with common values in the arrays

function HRLib.table.focusedHash(
    hash: table<string, table<string, any>[]>,
    focus: table|any,
    cb: fun(key: string, value: string, arrayInfo: { i: integer, curr: any })
)

Parameters description

• hash - the hash table to filter the keys from

• focus - the table that includes the filter values or any value to find match with the values from the array

• cb - the function that is being triggered when a match is found

Example 1

local hash = {
    player_1 = {
        {
            accountName = 'bank',
            balance = 2500
        },
        {
            accountName = 'cash',
            balance = 1000
        }
    },
    player_2 = {
        {
            accountName = 'bank',
            balance = 7000
        },
        {
            accountName = 'cash',
            balance = 3000
        }
    }
}

HRLib.table.focusedHash(hash, { accountName = 'bank' }, function(k, v, arrayInfo)
    print(k, arrayInfo.curr.balance)
end)
--[[ Ouput is two returned values:
    player_1    2500
    player_2    7000
]]

Example 2

local hash = {
    player_1 = {
        'Frankie Bird',
        'Police Officer'
    },
    player_2 = {
        'Santiago Johns',
        'Paramedic'
    },
    player_3 = {
        'Terrance McMillan',
        'Police Officer'
    }
}

HRLib.table.focusedHash(hash, 'Police Officer', function(k, v, arrayInfo)
    print(arrayInfo.curr)
end)
--[[ Ouput is two returned values:
    Frankie Bird
    Terrance McMillan
]]

table.getHashLength

Function to get the number of keys with values in a hash table (if in any scenario you're gonna need it)

function HRLib.table.getHashLength(hash: table): integer

Parameters description

• hash - the hash table to get the length of

table.find

Function to values in any table and different kinds of value

function HRLib.table.find(
    tbl: any[]|table,
    value: any|any[]|table,
    returnIndex: boolean?,
    isValueKey: boolean?,
    returnUnderIndex: boolean?
):
boolean isFound,
integer|integer[]? index,
string|string[]? underIndex

Parameters description

• tbl - the table to search the value in

• value - the value to search a match with

• returnIndex - sets whether or not the index should be returned

• isValueKey - sets whether or not the function should be focused on finding a key match instead of value match

• returnUnderIndex - sets whether or not the underIndex should be returned if there is underIndex (not tested, not completely done logic)

Return description

• isFound - contains the status (is a match found or not)

• index - contains the index(es) of the given table where the match is found (only available if returnIndex is true)

• underIndex - contains a string of the underIndex(es) (only available if returnUnderIndex is true) (not tested, don't recommend to use before fixing its logic and test it)

Example 1

local playerVehicles = {
    '888DD221',
    '000124FD',
    '32551AQK'
}

local found = HRLib.table.find(playerVehicles, '888DD221')
if found then
    print('The player owns the vehicle')
end
-- The output is:
-- "The player owns the vehicle" (because the value '888DD221' is found in the table)

Example 2

local playerVehicles = {
    futo = {
        plate = '888DD221'
    },
    asbo = {
        plate = '000124FD'
    }
}

local found = HRLib.table.find(playerVehicles, 'futo', nil, true)
if found then
    print('The player owns a vehicle with model futo')
end
-- It will print it because a value with key 'futo' is found in the table
-- But for that purpose we use the parameter isValueKey to focus the function
-- on seaching for a key match with the given value

Example 3

local playerVehicles = {
    ['888DD221'] = {
        model = 'futo'
    },
    ['000124FD'] = {
        model = 'asbo'
    },
    ['32551AQK'] = {
        model = 'futo'
    }
}

local found, index = HRLib.table.find(playerVehicles, { model = 'futo' }, true)
if found then
    if type(index) == 'table' then
        print('The player has more than one vehicle with model futo in its garage')
    else
        print('The player has only one vehicle with model futo in its garage')
    end
end
-- It will print "The player has more than one vehicle with model futo in its garage"
-- because more than one value in the table with underTable's value model is found as futo

table.deepclone

Function to make a deepclone of a table so its changes won't change the main one

function HRLib.table.deepclone(tbl: table, dontCopyMetatable: boolean?): table

Parameters description

• tbl - the table to make the deepclone of

• dontCopyMetatable - sets whether or not if a metatable exists of the given table, it should be copied

cloneStateBag

Function to clone a state bag so you can't lose its value even after it's removed

function HRLib.table.closeStateBag(bagName: string): any[]|false

Parameters description

• bagName - the state bag name to clone

table.compare

Function to compare if all values of two tables are same (like tbl1 == tb2 it works with deepcloned tables, because otherwise they won't match because their table identifiers are different)

function HRLib.table.compare(
    tbl1: table,
    tbl2: table,
    noKeyCompare: boolean?
): boolean

Parameters description

• tbl1 - the first table for the match

• tbl2 - the second table for the match

• noKeyCompare - sets whether or not the function should compare and with keys or not (true to compare tables only with their values, false to compare keys too)

table.getKeys

Function to get a table's keys in an array of strings or multiple values

function HRLib.table.getKeys(tbl: table, isArray: boolean?): ...|string[]?

Parameters description

• tbl - the table to get the keys of

• isArray - sets whether or not the return value must be in array format or not