# Shared

## table.focusedArray

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

```lua
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

```lua
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

```lua
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

```lua
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

```lua
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)

```lua
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

```lua
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

```lua
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

```lua
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

```lua
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

```lua
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

```lua
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)

```lua
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

```lua
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
