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

table.toString

Function to convert lua tables into visible strings that can be loaded via load function, (helpful for .lua metadata files)

function HRLib.table.toString(
    tbl: table,
    indent: boolean?,
    rowsSpace: integer?
): string?

Parameters description

• tbl - the target table to convert to string

• indent - sets whether or not the string should include new rows, tabs and so forth just like the lua tables usually look when they're being created or the string should include the table on one row.

• rowsSpace - the number of new rows between values declaration (by default it's 1)