Your IP : 216.73.216.11
home/digilove/public_html/libraries/regularlabs/src/ArrayHelper.php 0000644 00000026242 15234644740 0021614 0 ustar 00 <?php
/**
* @package Regular Labs Library
* @version 23.7.24631
*
* @author Peter van Westen <info@regularlabs.com>
* @link https://regularlabs.com
* @copyright Copyright © 2023 Regular Labs All Rights Reserved
* @license GNU General Public License version 2 or later
*/
namespace RegularLabs\Library;
defined('_JEXEC') or die;
/**
* Class ArrayHelper
* @package RegularLabs\Library
*/
class ArrayHelper
{
/**
* Add a postfix to all keys in an array
*
* @param array $array
* @param string $postfix
*
* @return array
*/
public static function AddPostfixToKeys($array, $postfix)
{
$pefixed = [];
foreach ($array as $key => $value)
{
$pefixed[StringHelper::addPostfix($key, $postfix)] = $value;
}
return $pefixed;
}
/**
* Add a postfix to all string values in an array
*
* @param array $array
* @param string $postfix
*
* @return array
*/
public static function AddPostfixToValues($array, $postfix)
{
foreach ($array as &$value)
{
$value = StringHelper::addPostfix($value, $postfix);
}
return $array;
}
/**
* Add a prefix to all keys in an array
*
* @param array $array
* @param string $prefix
*
* @return array
*/
public static function AddPrefixToKeys($array, $prefix)
{
$pefixed = [];
foreach ($array as $key => $value)
{
$pefixed[StringHelper::addPrefix($key, $prefix)] = $value;
}
return $pefixed;
}
/**
* Add a prefix to all string values in an array
*
* @param array $array
* @param string $prefix
* @param bool $keep_leading_slash
*
* @return array
*/
public static function AddPrefixToValues($array, $prefix, $keep_leading_slash = true)
{
foreach ($array as &$value)
{
$value = StringHelper::addPrefix($value, $prefix, $keep_leading_slash);
}
return $array;
}
/**
* Run a method over all values inside the array or object
*
* @param array $attributes
* @param string $class
* @param string $method
*
* @return array|object
*/
public static function applyMethodToKeys($attributes, $class = '', $method = '')
{
if ( ! $class || ! $method)
{
$caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1];
$class = $caller['class'];
$method = $caller['function'];
}
$array = array_shift($attributes);
if ( ! is_array($array) && ! is_object($array))
{
return null;
}
if (empty($array))
{
return $array;
}
$json = json_encode($array);
foreach ($array as $key => $value)
{
$value_attributes = [$key] + $attributes;
$json = str_replace(
'"' . $key . '":',
'"' . $class::$method(...$value_attributes) . '":',
$json
);
}
return json_decode($json);
}
/**
* Run a method over all values inside the array or object
*
* @param array $attributes
* @param string $class
* @param string $method
*
* @return array|object
*/
public static function applyMethodToValues($attributes, $class = '', $method = '')
{
if ( ! $class || ! $method)
{
$caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1];
$class = $caller['class'];
$method = $caller['function'];
}
$array = array_shift($attributes);
if ( ! is_array($array) && ! is_object($array))
{
return null;
}
foreach ($array as &$value)
{
if ( ! is_string($value))
{
continue;
}
$value_attributes = array_merge([$value], $attributes);
$value = $class::$method(...$value_attributes);
}
return $array;
}
/**
* Clean array by trimming values and removing empty/false values
*
* @param array $array
*
* @return array
*/
public static function clean($array)
{
if ( ! is_array($array))
{
return $array;
}
$array = self::trim($array);
$array = self::unique($array);
$array = self::removeEmpty($array);
return $array;
}
/**
* Check if any of the given values is found in the array
*
* @param array $needles
* @param array $haystack
*
* @return boolean
*/
public static function find($needles, $haystack)
{
if ( ! is_array($haystack) || empty($haystack))
{
return false;
}
$needles = self::toArray($needles);
foreach ($needles as $value)
{
if (in_array($value, $haystack))
{
return true;
}
}
return false;
}
/**
* Flatten an array of nested arrays, keeping the order
*
* @param array $array
*
* @return array
*/
public static function flatten($array)
{
$flattened = [];
foreach ($array as $nested)
{
if ( ! is_array($nested))
{
$flattened[] = $nested;
continue;
}
$flattened = array_merge($flattened, self::flatten($nested));
}
return $flattened;
}
/**
* Join array elements with a string
*
* @param array|string $pieces
* @param string $glue
* @param string $last_glue
*
* @return string
*/
public static function implode($pieces, $glue = '', $last_glue = null)
{
if ( ! is_array($pieces))
{
$pieces = self::toArray($pieces, $glue);
}
if (is_null($last_glue)
|| $last_glue == $glue
|| count($pieces) < 2
)
{
return implode($glue, $pieces);
}
$last_item = array_pop($pieces);
return implode($glue, $pieces) . $last_glue . $last_item;
}
/**
* Removes empty values from the array
*
* @param array $array
*
* @return array
*/
public static function removeEmpty($array)
{
if ( ! is_array($array))
{
return $array;
}
foreach ($array as $key => &$value)
{
if ($key && ! is_numeric($key))
{
continue;
}
if ($value !== '')
{
continue;
}
unset($array[$key]);
}
return $array;
}
/**
* Removes the trailing part of all keys in an array
*
* @param array $array
* @param string $postfix
*
* @return array
*/
public static function removePostfixFromKeys($array, $postfix)
{
$pefixed = [];
foreach ($array as $key => $value)
{
$pefixed[StringHelper::removePostfix($key, $postfix)] = $value;
}
return $pefixed;
}
/**
* Removes the trailing part of all string values in an array
*
* @param array $array
* @param string $postfix
*
* @return array
*/
public static function removePostfixFromValues($array, $postfix)
{
foreach ($array as &$value)
{
$value = StringHelper::removePostfix($value, $postfix);
}
return $array;
}
/**
* Removes the first part of all keys in an array
*
* @param array $array
* @param string $prefix
*
* @return array
*/
public static function removePrefixFromKeys($array, $prefix)
{
$pefixed = [];
foreach ($array as $key => $value)
{
$pefixed[StringHelper::removePrefix($key, $prefix)] = $value;
}
return $pefixed;
}
/**
* Removes the first part of all string values in an array
*
* @param array $array
* @param string $prefix
* @param bool $keep_leading_slash
*
* @return array
*/
public static function removePrefixFromValues($array, $prefix, $keep_leading_slash = true)
{
foreach ($array as &$value)
{
$value = StringHelper::removePrefix($value, $prefix, $keep_leading_slash);
}
return $array;
}
/**
* Sorts the array by keys based on the values of another array
*
* @param array $array
* @param array $order
*
* @return array
*/
public static function sortByOtherArray($array, $order)
{
if (empty($order))
{
return $array;
}
uksort($array, function ($key1, $key2) use ($order) {
return array_search($key1, $order) > array_search($key2, $order);
});
return $array;
}
/**
* Convert data (string or object) to an array
*
* @param mixed $data
* @param string $separator
* @param bool $unique
*
* @return array
*/
public static function toArray($data, $separator = ',', $unique = false, $trim = true)
{
if (is_array($data))
{
return $data;
}
if (is_object($data))
{
return (array) $data;
}
if ($data === '' || is_null($data))
{
return [];
}
if ($separator === '')
{
return [$data];
}
// explode on separator, but keep escaped separators
$splitter = uniqid('RL_SPLIT');
$data = str_replace($separator, $splitter, $data);
$data = str_replace('\\' . $splitter, $separator, $data);
$array = explode($splitter, $data);
if ($trim)
{
$array = self::trim($array);
}
if ($unique)
{
$array = array_unique($array);
}
return $array;
}
/**
* Clean array by trimming values
*
* @param array $array
*
* @return array
*/
public static function trim($array)
{
if ( ! is_array($array))
{
return $array;
}
foreach ($array as &$value)
{
if ( ! is_string($value))
{
continue;
}
$value = trim($value);
}
return $array;
}
/**
* Removes duplicate values from the array
*
* @param array $array
*
* @return array
*/
public static function unique($array)
{
if ( ! is_array($array))
{
return $array;
}
$values = [];
foreach ($array as $key => $value)
{
if ( ! is_numeric($key))
{
continue;
}
if ( ! in_array($value, $values))
{
$values[] = $value;
continue;
}
unset($array[$key]);
}
return $array;
}
}
home/digilove/public_html/libraries/fof40/Utils/ArrayHelper.php 0000644 00000031500 15235165417 0020531 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2022 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace FOF40\Utils;
defined('_JEXEC') || die;
/**
* ArrayHelper is an array utility class for doing all sorts of odds and ends with arrays.
*
* Copied from Joomla Framework to avoid class name issues between Joomla! versions 3 and 4. sortObjects is not included
* because it needs the UTF-8 package. If you need to use that then you should be using the Joomla! Framework's helper
* anyway.
*/
final class ArrayHelper
{
/**
* Private constructor to prevent instantiation of this class
*
* @since 1.0
*/
private function __construct()
{
}
/**
* Function to convert array to integer values
*
* @param array $array The source array to convert
* @param int|array|null $default A default value (int|array) to assign if $array is not an array
*
* @return int[]
*
* @since 1.0
*/
public static function toInteger(array $array, $default = null): array
{
if (is_array($array))
{
return array_map('intval', $array);
}
if ($default === null)
{
return [];
}
if (is_array($default))
{
return static::toInteger($default, null);
}
return [(int) $default];
}
/**
* Utility function to map an array to a stdClass object.
*
* @param array $array The array to map.
* @param string $class Name of the class to create
* @param boolean $recursive Convert also any array inside the main array
*
* @return object
*
* @since 1.0
*/
public static function toObject(array $array, string $class = 'stdClass', bool $recursive = true)
{
$obj = new $class;
foreach ($array as $k => $v)
{
$obj->$k = ($recursive && is_array($v)) ? static::toObject($v, $class) : $v;
}
return $obj;
}
/**
* Utility function to map an array to a string.
*
* @param array $array The array to map.
* @param string $inner_glue The glue (optional, defaults to '=') between the key and the value.
* @param string $outer_glue The glue (optional, defaults to ' ') between array elements.
* @param boolean $keepOuterKey True if final key should be kept.
*
* @return string
*
* @since 1.0
*/
public static function toString(array $array, string $inner_glue = '=', string $outer_glue = ' ', bool $keepOuterKey = false): string
{
$output = [];
foreach ($array as $key => $item)
{
if (is_array($item))
{
if ($keepOuterKey)
{
$output[] = $key;
}
// This is value is an array, go and do it again!
$output[] = static::toString($item, $inner_glue, $outer_glue, $keepOuterKey);
}
else
{
$output[] = $key . $inner_glue . '"' . $item . '"';
}
}
return implode($outer_glue, $output);
}
/**
* Utility function to map an object to an array
*
* @param object $p_obj The source object
* @param boolean $recurse True to recurse through multi-level objects
* @param string|null $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
public static function fromObject($p_obj, bool $recurse = true, ?string $regex = null): array
{
if (is_object($p_obj) || is_array($p_obj))
{
return self::arrayFromObject($p_obj, $recurse, $regex);
}
return [];
}
/**
* Extracts a column from an array of arrays or objects
*
* @param array $array The source array
* @param string $valueCol The index of the column or name of object property to be used as value
* It may also be NULL to return complete arrays or objects (this is
* useful together with <var>$keyCol</var> to reindex the array).
* @param string|null $keyCol The index of the column or name of object property to be used as key
*
* @return array Column of values from the source array
*
* @since 1.0
* @see http://php.net/manual/en/language.types.array.php
* @see http://php.net/manual/en/function.array-column.php
*/
public static function getColumn(array $array, string $valueCol, ?string $keyCol = null): array
{
$result = [];
foreach ($array as $item)
{
// Convert object to array
$subject = is_object($item) ? static::fromObject($item) : $item;
/*
* We process arrays (and objects already converted to array)
* Only if the value column (if required) exists in this item
*/
if (is_array($subject) && (!isset($valueCol) || isset($subject[$valueCol])))
{
// Use whole $item if valueCol is null, else use the value column.
$value = isset($valueCol) ? $subject[$valueCol] : $item;
// Array keys can only be integer or string. Casting will occur as per the PHP Manual.
if (isset($keyCol) && isset($subject[$keyCol]) && is_scalar($subject[$keyCol]))
{
$key = $subject[$keyCol];
$result[$key] = $value;
}
else
{
$result[] = $value;
}
}
}
return $result;
}
/**
* Utility function to return a value from a named array or a specified default
*
* @param array|\ArrayAccess $array A named array or object that implements ArrayAccess
* @param string $name The key to search for
* @param mixed $default The default value to give if no key found
* @param string $type Return type for the variable (INT, FLOAT, STRING, WORD, BOOLEAN, ARRAY)
*
* @return mixed
*
* @throws \InvalidArgumentException
* @since 1.0
*/
public static function getValue(array $array, string $name, $default = null, string $type = '')
{
if (!is_array($array) && !($array instanceof \ArrayAccess))
{
throw new \InvalidArgumentException('The object must be an array or an object that implements ArrayAccess');
}
$result = null;
if (isset($array[$name]))
{
$result = $array[$name];
}
// Handle the default case
if (is_null($result))
{
$result = $default;
}
// Handle the type constraint
switch (strtoupper($type))
{
case 'INT':
case 'INTEGER':
// Only use the first integer value
@preg_match('/-?\d+/', $result, $matches);
$result = @(int) $matches[0];
break;
case 'FLOAT':
case 'DOUBLE':
// Only use the first floating point value
@preg_match('/-?\d+(\.\d+)?/', $result, $matches);
$result = @(float) $matches[0];
break;
case 'BOOL':
case 'BOOLEAN':
$result = (bool) $result;
break;
case 'ARRAY':
if (!is_array($result))
{
$result = [$result];
}
break;
case 'STRING':
$result = (string) $result;
break;
case 'WORD':
$result = (string) preg_replace('#\W#', '', $result);
break;
case 'NONE':
default:
// No casting necessary
break;
}
return $result;
}
/**
* Takes an associative array of arrays and inverts the array keys to values using the array values as keys.
*
* Example:
* $input = array(
* 'New' => array('1000', '1500', '1750'),
* 'Used' => array('3000', '4000', '5000', '6000')
* );
* $output = ArrayHelper::invert($input);
*
* Output would be equal to:
* $output = array(
* '1000' => 'New',
* '1500' => 'New',
* '1750' => 'New',
* '3000' => 'Used',
* '4000' => 'Used',
* '5000' => 'Used',
* '6000' => 'Used'
* );
*
* @param array $array The source array.
*
* @return array
*
* @since 1.0
*/
public static function invert(array $array): array
{
$return = [];
foreach ($array as $base => $values)
{
if (!is_array($values))
{
continue;
}
foreach ($values as $key)
{
// If the key isn't scalar then ignore it.
if (is_scalar($key))
{
$return[$key] = $base;
}
}
}
return $return;
}
/**
* Method to determine if an array is an associative array.
*
* @param array $array An array to test.
*
* @return boolean
*
* @since 1.0
*/
public static function isAssociative(array $array): bool
{
if (is_array($array))
{
foreach (array_keys($array) as $k => $v)
{
if ($k !== $v)
{
return true;
}
}
}
return false;
}
/**
* Pivots an array to create a reverse lookup of an array of scalars, arrays or objects.
*
* @param array $source The source array.
* @param string|null $key Where the elements of the source array are objects or arrays, the key to pivot
* on.
*
* @return array An array of arrays pivoted either on the value of the keys, or an individual key of an object or
* array.
*
* @since 1.0
*/
public static function pivot(array $source, ?string $key = null): array
{
$result = [];
$counter = [];
foreach ($source as $index => $value)
{
// Determine the name of the pivot key, and its value.
if (is_array($value))
{
// If the key does not exist, ignore it.
if (!isset($value[$key]))
{
continue;
}
$resultKey = $value[$key];
$resultValue = $source[$index];
}
elseif (is_object($value))
{
// If the key does not exist, ignore it.
if (!isset($value->$key))
{
continue;
}
$resultKey = $value->$key;
$resultValue = $source[$index];
}
else
{
// Just a scalar value.
$resultKey = $value;
$resultValue = $index;
}
// The counter tracks how many times a key has been used.
if (empty($counter[$resultKey]))
{
// The first time around we just assign the value to the key.
$result[$resultKey] = $resultValue;
$counter[$resultKey] = 1;
}
elseif ($counter[$resultKey] == 1)
{
// If there is a second time, we convert the value into an array.
$result[$resultKey] = [
$result[$resultKey],
$resultValue,
];
$counter[$resultKey]++;
}
else
{
// After the second time, no need to track any more. Just append to the existing array.
$result[$resultKey][] = $resultValue;
}
}
unset($counter);
return $result;
}
/**
* Multidimensional-array-safe unique test
*
* @param array $array The array to make unique.
*
* @return array
*
* @see http://php.net/manual/en/function.array-unique.php
* @since 1.0
*/
public static function arrayUnique(array $array): array
{
$array = array_map('serialize', $array);
$array = array_unique($array);
return array_map('unserialize', $array);
}
/**
* An improved array_search that allows for partial matching of strings values in associative arrays.
*
* @param string $needle The text to search for within the array.
* @param array $haystack Associative array to search in to find $needle.
* @param boolean $caseSensitive True to search case sensitive, false otherwise.
*
* @return mixed Returns the matching array $key if found, otherwise false.
*
* @since 1.0
*/
public static function arraySearch(string $needle, array $haystack, bool $caseSensitive = true)
{
foreach ($haystack as $key => $value)
{
$searchFunc = ($caseSensitive) ? 'strpos' : 'stripos';
if ($searchFunc($value, $needle) === 0)
{
return $key;
}
}
return false;
}
/**
* Method to recursively convert data to a one dimension array.
*
* @param array|object $array The array or object to convert.
* @param string $separator The key separator.
* @param string $prefix Last level key prefix.
*
* @return array
*
* @since 1.3.0
*/
public static function flatten($array, string $separator = '.', string $prefix = ''): array
{
if ($array instanceof \Traversable)
{
$array = iterator_to_array($array);
}
elseif (is_object($array))
{
$array = get_object_vars($array);
}
foreach ($array as $k => $v)
{
$key = $prefix ? ($prefix . $separator . $k) : $k;
if (is_object($v) || is_array($v))
{
$array = array_merge($array, static::flatten($v, $separator, $key));
}
else
{
$array[$key] = $v;
}
}
return $array;
}
/**
* Utility function to map an object or array to an array
*
* @param mixed $item The source object or array
* @param boolean $recurse True to recurse through multi-level objects
* @param string $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
private static function arrayFromObject($item, bool $recurse, ?string $regex): array
{
if (is_object($item))
{
$result = [];
foreach (get_object_vars($item) as $k => $v)
{
if (!$regex || preg_match($regex, $k))
{
$result[$k] = $recurse ? self::arrayFromObject($v, $recurse, $regex) : $v;
}
}
return $result;
}
if (is_array($item))
{
$result = [];
foreach ($item as $k => $v)
{
$result[$k] = self::arrayFromObject($v, $recurse, $regex);
}
return $result;
}
return $item;
}
}
home/digilove/public_html/libraries/fof30/Utils/ArrayHelper.php 0000644 00000031260 15235577024 0020534 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2019 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU GPL version 2 or later
*/
namespace FOF30\Utils;
defined('_JEXEC') or die;
/**
* ArrayHelper is an array utility class for doing all sorts of odds and ends with arrays.
*
* Copied from Joomla Framework to avoid class name issues between Joomla! versions 3 and 4. sortObjects is not included
* because it needs the UTF-8 package. If you need to use that then you should be using the Joomla! Framework's helper
* anyway.
*/
final class ArrayHelper
{
/**
* Private constructor to prevent instantiation of this class
*
* @since 1.0
*/
private function __construct()
{
}
/**
* Function to convert array to integer values
*
* @param array $array The source array to convert
* @param mixed $default A default value (int|array) to assign if $array is not an array
*
* @return array
*
* @since 1.0
*/
public static function toInteger($array, $default = null)
{
if (is_array($array))
{
return array_map('intval', $array);
}
if ($default === null)
{
return array();
}
if (is_array($default))
{
return static::toInteger($default, null);
}
return array((int) $default);
}
/**
* Utility function to map an array to a stdClass object.
*
* @param array $array The array to map.
* @param string $class Name of the class to create
* @param boolean $recursive Convert also any array inside the main array
*
* @return object
*
* @since 1.0
*/
public static function toObject(array $array, $class = 'stdClass', $recursive = true)
{
$obj = new $class;
foreach ($array as $k => $v)
{
if ($recursive && is_array($v))
{
$obj->$k = static::toObject($v, $class);
}
else
{
$obj->$k = $v;
}
}
return $obj;
}
/**
* Utility function to map an array to a string.
*
* @param array $array The array to map.
* @param string $inner_glue The glue (optional, defaults to '=') between the key and the value.
* @param string $outer_glue The glue (optional, defaults to ' ') between array elements.
* @param boolean $keepOuterKey True if final key should be kept.
*
* @return string
*
* @since 1.0
*/
public static function toString(array $array, $inner_glue = '=', $outer_glue = ' ', $keepOuterKey = false)
{
$output = array();
foreach ($array as $key => $item)
{
if (is_array($item))
{
if ($keepOuterKey)
{
$output[] = $key;
}
// This is value is an array, go and do it again!
$output[] = static::toString($item, $inner_glue, $outer_glue, $keepOuterKey);
}
else
{
$output[] = $key . $inner_glue . '"' . $item . '"';
}
}
return implode($outer_glue, $output);
}
/**
* Utility function to map an object to an array
*
* @param object $p_obj The source object
* @param boolean $recurse True to recurse through multi-level objects
* @param string $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
public static function fromObject($p_obj, $recurse = true, $regex = null)
{
if (is_object($p_obj) || is_array($p_obj))
{
return self::arrayFromObject($p_obj, $recurse, $regex);
}
return array();
}
/**
* Utility function to map an object or array to an array
*
* @param mixed $item The source object or array
* @param boolean $recurse True to recurse through multi-level objects
* @param string $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
private static function arrayFromObject($item, $recurse, $regex)
{
if (is_object($item))
{
$result = array();
foreach (get_object_vars($item) as $k => $v)
{
if (!$regex || preg_match($regex, $k))
{
if ($recurse)
{
$result[$k] = self::arrayFromObject($v, $recurse, $regex);
}
else
{
$result[$k] = $v;
}
}
}
return $result;
}
if (is_array($item))
{
$result = array();
foreach ($item as $k => $v)
{
$result[$k] = self::arrayFromObject($v, $recurse, $regex);
}
return $result;
}
return $item;
}
/**
* Extracts a column from an array of arrays or objects
*
* @param array $array The source array
* @param string $valueCol The index of the column or name of object property to be used as value
* It may also be NULL to return complete arrays or objects (this is
* useful together with <var>$keyCol</var> to reindex the array).
* @param string $keyCol The index of the column or name of object property to be used as key
*
* @return array Column of values from the source array
*
* @since 1.0
* @see http://php.net/manual/en/language.types.array.php
* @see http://php.net/manual/en/function.array-column.php
*/
public static function getColumn(array $array, $valueCol, $keyCol = null)
{
$result = array();
foreach ($array as $item)
{
// Convert object to array
$subject = is_object($item) ? static::fromObject($item) : $item;
/*
* We process arrays (and objects already converted to array)
* Only if the value column (if required) exists in this item
*/
if (is_array($subject) && (!isset($valueCol) || isset($subject[$valueCol])))
{
// Use whole $item if valueCol is null, else use the value column.
$value = isset($valueCol) ? $subject[$valueCol] : $item;
// Array keys can only be integer or string. Casting will occur as per the PHP Manual.
if (isset($keyCol) && isset($subject[$keyCol]) && is_scalar($subject[$keyCol]))
{
$key = $subject[$keyCol];
$result[$key] = $value;
}
else
{
$result[] = $value;
}
}
}
return $result;
}
/**
* Utility function to return a value from a named array or a specified default
*
* @param array|\ArrayAccess $array A named array or object that implements ArrayAccess
* @param string $name The key to search for
* @param mixed $default The default value to give if no key found
* @param string $type Return type for the variable (INT, FLOAT, STRING, WORD, BOOLEAN, ARRAY)
*
* @return mixed
*
* @since 1.0
* @throws \InvalidArgumentException
*/
public static function getValue($array, $name, $default = null, $type = '')
{
if (!is_array($array) && !($array instanceof \ArrayAccess))
{
throw new \InvalidArgumentException('The object must be an array or an object that implements ArrayAccess');
}
$result = null;
if (isset($array[$name]))
{
$result = $array[$name];
}
// Handle the default case
if (is_null($result))
{
$result = $default;
}
// Handle the type constraint
switch (strtoupper($type))
{
case 'INT':
case 'INTEGER':
// Only use the first integer value
@preg_match('/-?[0-9]+/', $result, $matches);
$result = @(int) $matches[0];
break;
case 'FLOAT':
case 'DOUBLE':
// Only use the first floating point value
@preg_match('/-?[0-9]+(\.[0-9]+)?/', $result, $matches);
$result = @(float) $matches[0];
break;
case 'BOOL':
case 'BOOLEAN':
$result = (bool) $result;
break;
case 'ARRAY':
if (!is_array($result))
{
$result = array($result);
}
break;
case 'STRING':
$result = (string) $result;
break;
case 'WORD':
$result = (string) preg_replace('#\W#', '', $result);
break;
case 'NONE':
default:
// No casting necessary
break;
}
return $result;
}
/**
* Takes an associative array of arrays and inverts the array keys to values using the array values as keys.
*
* Example:
* $input = array(
* 'New' => array('1000', '1500', '1750'),
* 'Used' => array('3000', '4000', '5000', '6000')
* );
* $output = ArrayHelper::invert($input);
*
* Output would be equal to:
* $output = array(
* '1000' => 'New',
* '1500' => 'New',
* '1750' => 'New',
* '3000' => 'Used',
* '4000' => 'Used',
* '5000' => 'Used',
* '6000' => 'Used'
* );
*
* @param array $array The source array.
*
* @return array
*
* @since 1.0
*/
public static function invert(array $array)
{
$return = array();
foreach ($array as $base => $values)
{
if (!is_array($values))
{
continue;
}
foreach ($values as $key)
{
// If the key isn't scalar then ignore it.
if (is_scalar($key))
{
$return[$key] = $base;
}
}
}
return $return;
}
/**
* Method to determine if an array is an associative array.
*
* @param array $array An array to test.
*
* @return boolean
*
* @since 1.0
*/
public static function isAssociative($array)
{
if (is_array($array))
{
foreach (array_keys($array) as $k => $v)
{
if ($k !== $v)
{
return true;
}
}
}
return false;
}
/**
* Pivots an array to create a reverse lookup of an array of scalars, arrays or objects.
*
* @param array $source The source array.
* @param string $key Where the elements of the source array are objects or arrays, the key to pivot on.
*
* @return array An array of arrays pivoted either on the value of the keys, or an individual key of an object or array.
*
* @since 1.0
*/
public static function pivot(array $source, $key = null)
{
$result = array();
$counter = array();
foreach ($source as $index => $value)
{
// Determine the name of the pivot key, and its value.
if (is_array($value))
{
// If the key does not exist, ignore it.
if (!isset($value[$key]))
{
continue;
}
$resultKey = $value[$key];
$resultValue = $source[$index];
}
elseif (is_object($value))
{
// If the key does not exist, ignore it.
if (!isset($value->$key))
{
continue;
}
$resultKey = $value->$key;
$resultValue = $source[$index];
}
else
{
// Just a scalar value.
$resultKey = $value;
$resultValue = $index;
}
// The counter tracks how many times a key has been used.
if (empty($counter[$resultKey]))
{
// The first time around we just assign the value to the key.
$result[$resultKey] = $resultValue;
$counter[$resultKey] = 1;
}
elseif ($counter[$resultKey] == 1)
{
// If there is a second time, we convert the value into an array.
$result[$resultKey] = array(
$result[$resultKey],
$resultValue,
);
$counter[$resultKey]++;
}
else
{
// After the second time, no need to track any more. Just append to the existing array.
$result[$resultKey][] = $resultValue;
}
}
unset($counter);
return $result;
}
/**
* Multidimensional array safe unique test
*
* @param array $array The array to make unique.
*
* @return array
*
* @see http://php.net/manual/en/function.array-unique.php
* @since 1.0
*/
public static function arrayUnique(array $array)
{
$array = array_map('serialize', $array);
$array = array_unique($array);
$array = array_map('unserialize', $array);
return $array;
}
/**
* An improved array_search that allows for partial matching of strings values in associative arrays.
*
* @param string $needle The text to search for within the array.
* @param array $haystack Associative array to search in to find $needle.
* @param boolean $caseSensitive True to search case sensitive, false otherwise.
*
* @return mixed Returns the matching array $key if found, otherwise false.
*
* @since 1.0
*/
public static function arraySearch($needle, array $haystack, $caseSensitive = true)
{
foreach ($haystack as $key => $value)
{
$searchFunc = ($caseSensitive) ? 'strpos' : 'stripos';
if ($searchFunc($value, $needle) === 0)
{
return $key;
}
}
return false;
}
/**
* Method to recursively convert data to a one dimension array.
*
* @param array|object $array The array or object to convert.
* @param string $separator The key separator.
* @param string $prefix Last level key prefix.
*
* @return array
*
* @since 1.3.0
*/
public static function flatten($array, $separator = '.', $prefix = '')
{
if ($array instanceof \Traversable)
{
$array = iterator_to_array($array);
}
elseif (is_object($array))
{
$array = get_object_vars($array);
}
foreach ($array as $k => $v)
{
$key = $prefix ? $prefix . $separator . $k : $k;
if (is_object($v) || is_array($v))
{
$array = array_merge($array, static::flatten($v, $separator, $key));
}
else
{
$array[$key] = $v;
}
}
return $array;
}
}
home/digilove/public_html/110/libraries/fof40/Utils/ArrayHelper.php 0000644 00000031500 15240037253 0021022 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2022 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace FOF40\Utils;
defined('_JEXEC') || die;
/**
* ArrayHelper is an array utility class for doing all sorts of odds and ends with arrays.
*
* Copied from Joomla Framework to avoid class name issues between Joomla! versions 3 and 4. sortObjects is not included
* because it needs the UTF-8 package. If you need to use that then you should be using the Joomla! Framework's helper
* anyway.
*/
final class ArrayHelper
{
/**
* Private constructor to prevent instantiation of this class
*
* @since 1.0
*/
private function __construct()
{
}
/**
* Function to convert array to integer values
*
* @param array $array The source array to convert
* @param int|array|null $default A default value (int|array) to assign if $array is not an array
*
* @return int[]
*
* @since 1.0
*/
public static function toInteger(array $array, $default = null): array
{
if (is_array($array))
{
return array_map('intval', $array);
}
if ($default === null)
{
return [];
}
if (is_array($default))
{
return static::toInteger($default, null);
}
return [(int) $default];
}
/**
* Utility function to map an array to a stdClass object.
*
* @param array $array The array to map.
* @param string $class Name of the class to create
* @param boolean $recursive Convert also any array inside the main array
*
* @return object
*
* @since 1.0
*/
public static function toObject(array $array, string $class = 'stdClass', bool $recursive = true)
{
$obj = new $class;
foreach ($array as $k => $v)
{
$obj->$k = ($recursive && is_array($v)) ? static::toObject($v, $class) : $v;
}
return $obj;
}
/**
* Utility function to map an array to a string.
*
* @param array $array The array to map.
* @param string $inner_glue The glue (optional, defaults to '=') between the key and the value.
* @param string $outer_glue The glue (optional, defaults to ' ') between array elements.
* @param boolean $keepOuterKey True if final key should be kept.
*
* @return string
*
* @since 1.0
*/
public static function toString(array $array, string $inner_glue = '=', string $outer_glue = ' ', bool $keepOuterKey = false): string
{
$output = [];
foreach ($array as $key => $item)
{
if (is_array($item))
{
if ($keepOuterKey)
{
$output[] = $key;
}
// This is value is an array, go and do it again!
$output[] = static::toString($item, $inner_glue, $outer_glue, $keepOuterKey);
}
else
{
$output[] = $key . $inner_glue . '"' . $item . '"';
}
}
return implode($outer_glue, $output);
}
/**
* Utility function to map an object to an array
*
* @param object $p_obj The source object
* @param boolean $recurse True to recurse through multi-level objects
* @param string|null $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
public static function fromObject($p_obj, bool $recurse = true, ?string $regex = null): array
{
if (is_object($p_obj) || is_array($p_obj))
{
return self::arrayFromObject($p_obj, $recurse, $regex);
}
return [];
}
/**
* Extracts a column from an array of arrays or objects
*
* @param array $array The source array
* @param string $valueCol The index of the column or name of object property to be used as value
* It may also be NULL to return complete arrays or objects (this is
* useful together with <var>$keyCol</var> to reindex the array).
* @param string|null $keyCol The index of the column or name of object property to be used as key
*
* @return array Column of values from the source array
*
* @since 1.0
* @see http://php.net/manual/en/language.types.array.php
* @see http://php.net/manual/en/function.array-column.php
*/
public static function getColumn(array $array, string $valueCol, ?string $keyCol = null): array
{
$result = [];
foreach ($array as $item)
{
// Convert object to array
$subject = is_object($item) ? static::fromObject($item) : $item;
/*
* We process arrays (and objects already converted to array)
* Only if the value column (if required) exists in this item
*/
if (is_array($subject) && (!isset($valueCol) || isset($subject[$valueCol])))
{
// Use whole $item if valueCol is null, else use the value column.
$value = isset($valueCol) ? $subject[$valueCol] : $item;
// Array keys can only be integer or string. Casting will occur as per the PHP Manual.
if (isset($keyCol) && isset($subject[$keyCol]) && is_scalar($subject[$keyCol]))
{
$key = $subject[$keyCol];
$result[$key] = $value;
}
else
{
$result[] = $value;
}
}
}
return $result;
}
/**
* Utility function to return a value from a named array or a specified default
*
* @param array|\ArrayAccess $array A named array or object that implements ArrayAccess
* @param string $name The key to search for
* @param mixed $default The default value to give if no key found
* @param string $type Return type for the variable (INT, FLOAT, STRING, WORD, BOOLEAN, ARRAY)
*
* @return mixed
*
* @throws \InvalidArgumentException
* @since 1.0
*/
public static function getValue(array $array, string $name, $default = null, string $type = '')
{
if (!is_array($array) && !($array instanceof \ArrayAccess))
{
throw new \InvalidArgumentException('The object must be an array or an object that implements ArrayAccess');
}
$result = null;
if (isset($array[$name]))
{
$result = $array[$name];
}
// Handle the default case
if (is_null($result))
{
$result = $default;
}
// Handle the type constraint
switch (strtoupper($type))
{
case 'INT':
case 'INTEGER':
// Only use the first integer value
@preg_match('/-?\d+/', $result, $matches);
$result = @(int) $matches[0];
break;
case 'FLOAT':
case 'DOUBLE':
// Only use the first floating point value
@preg_match('/-?\d+(\.\d+)?/', $result, $matches);
$result = @(float) $matches[0];
break;
case 'BOOL':
case 'BOOLEAN':
$result = (bool) $result;
break;
case 'ARRAY':
if (!is_array($result))
{
$result = [$result];
}
break;
case 'STRING':
$result = (string) $result;
break;
case 'WORD':
$result = (string) preg_replace('#\W#', '', $result);
break;
case 'NONE':
default:
// No casting necessary
break;
}
return $result;
}
/**
* Takes an associative array of arrays and inverts the array keys to values using the array values as keys.
*
* Example:
* $input = array(
* 'New' => array('1000', '1500', '1750'),
* 'Used' => array('3000', '4000', '5000', '6000')
* );
* $output = ArrayHelper::invert($input);
*
* Output would be equal to:
* $output = array(
* '1000' => 'New',
* '1500' => 'New',
* '1750' => 'New',
* '3000' => 'Used',
* '4000' => 'Used',
* '5000' => 'Used',
* '6000' => 'Used'
* );
*
* @param array $array The source array.
*
* @return array
*
* @since 1.0
*/
public static function invert(array $array): array
{
$return = [];
foreach ($array as $base => $values)
{
if (!is_array($values))
{
continue;
}
foreach ($values as $key)
{
// If the key isn't scalar then ignore it.
if (is_scalar($key))
{
$return[$key] = $base;
}
}
}
return $return;
}
/**
* Method to determine if an array is an associative array.
*
* @param array $array An array to test.
*
* @return boolean
*
* @since 1.0
*/
public static function isAssociative(array $array): bool
{
if (is_array($array))
{
foreach (array_keys($array) as $k => $v)
{
if ($k !== $v)
{
return true;
}
}
}
return false;
}
/**
* Pivots an array to create a reverse lookup of an array of scalars, arrays or objects.
*
* @param array $source The source array.
* @param string|null $key Where the elements of the source array are objects or arrays, the key to pivot
* on.
*
* @return array An array of arrays pivoted either on the value of the keys, or an individual key of an object or
* array.
*
* @since 1.0
*/
public static function pivot(array $source, ?string $key = null): array
{
$result = [];
$counter = [];
foreach ($source as $index => $value)
{
// Determine the name of the pivot key, and its value.
if (is_array($value))
{
// If the key does not exist, ignore it.
if (!isset($value[$key]))
{
continue;
}
$resultKey = $value[$key];
$resultValue = $source[$index];
}
elseif (is_object($value))
{
// If the key does not exist, ignore it.
if (!isset($value->$key))
{
continue;
}
$resultKey = $value->$key;
$resultValue = $source[$index];
}
else
{
// Just a scalar value.
$resultKey = $value;
$resultValue = $index;
}
// The counter tracks how many times a key has been used.
if (empty($counter[$resultKey]))
{
// The first time around we just assign the value to the key.
$result[$resultKey] = $resultValue;
$counter[$resultKey] = 1;
}
elseif ($counter[$resultKey] == 1)
{
// If there is a second time, we convert the value into an array.
$result[$resultKey] = [
$result[$resultKey],
$resultValue,
];
$counter[$resultKey]++;
}
else
{
// After the second time, no need to track any more. Just append to the existing array.
$result[$resultKey][] = $resultValue;
}
}
unset($counter);
return $result;
}
/**
* Multidimensional-array-safe unique test
*
* @param array $array The array to make unique.
*
* @return array
*
* @see http://php.net/manual/en/function.array-unique.php
* @since 1.0
*/
public static function arrayUnique(array $array): array
{
$array = array_map('serialize', $array);
$array = array_unique($array);
return array_map('unserialize', $array);
}
/**
* An improved array_search that allows for partial matching of strings values in associative arrays.
*
* @param string $needle The text to search for within the array.
* @param array $haystack Associative array to search in to find $needle.
* @param boolean $caseSensitive True to search case sensitive, false otherwise.
*
* @return mixed Returns the matching array $key if found, otherwise false.
*
* @since 1.0
*/
public static function arraySearch(string $needle, array $haystack, bool $caseSensitive = true)
{
foreach ($haystack as $key => $value)
{
$searchFunc = ($caseSensitive) ? 'strpos' : 'stripos';
if ($searchFunc($value, $needle) === 0)
{
return $key;
}
}
return false;
}
/**
* Method to recursively convert data to a one dimension array.
*
* @param array|object $array The array or object to convert.
* @param string $separator The key separator.
* @param string $prefix Last level key prefix.
*
* @return array
*
* @since 1.3.0
*/
public static function flatten($array, string $separator = '.', string $prefix = ''): array
{
if ($array instanceof \Traversable)
{
$array = iterator_to_array($array);
}
elseif (is_object($array))
{
$array = get_object_vars($array);
}
foreach ($array as $k => $v)
{
$key = $prefix ? ($prefix . $separator . $k) : $k;
if (is_object($v) || is_array($v))
{
$array = array_merge($array, static::flatten($v, $separator, $key));
}
else
{
$array[$key] = $v;
}
}
return $array;
}
/**
* Utility function to map an object or array to an array
*
* @param mixed $item The source object or array
* @param boolean $recurse True to recurse through multi-level objects
* @param string $regex An optional regular expression to match on field names
*
* @return array
*
* @since 1.0
*/
private static function arrayFromObject($item, bool $recurse, ?string $regex): array
{
if (is_object($item))
{
$result = [];
foreach (get_object_vars($item) as $k => $v)
{
if (!$regex || preg_match($regex, $k))
{
$result[$k] = $recurse ? self::arrayFromObject($v, $recurse, $regex) : $v;
}
}
return $result;
}
if (is_array($item))
{
$result = [];
foreach ($item as $k => $v)
{
$result[$k] = self::arrayFromObject($v, $recurse, $regex);
}
return $result;
}
return $item;
}
}