system/helpers/arr.php

   1 <?php defined('SYSPATH') OR die('No direct access allowed.');
   2 /**
   3  * Array helper class.
   4  *
   5  * $Id: arr.php 3917 2009-01-21 03:06:22Z zombor $
   6  *
   7  * @package    Core
   8  * @author     Kohana Team
   9  * @copyright  (c) 2007-2008 Kohana Team
  10  * @license    http://kohanaphp.com/license.html
  11  */
  12 class arr {
  13
  14         /**
  15          * Return a callback array from a string, eg: limit[10,20] would become
  16          * array('limit', array('10', '20'))
  17          *
  18          * @param   string  callback string
  19          * @return  array
  20          */
  21         public static function callback_string($str)
  22         {
  23                 // command[param,param]
  24                 if (preg_match('/([^\[]*+)\[(.+)\]/', (string) $str, $match))
  25                 {
  26                         // command
  27                         $command = $match[1];
  28
  29                         // param,param
  30                         $params = preg_split('/(?<!\\\\),/', $match[2]);
  31                         $params = str_replace('\,', ',', $params);
  32                 }
  33                 else
  34                 {
  35                         // command
  36                         $command = $str;
  37
  38                         // No params
  39                         $params = NULL;
  40                 }
  41
  42                 return array($command, $params);
  43         }
  44
  45         /**
  46          * Rotates a 2D array clockwise.
  47          * Example, turns a 2x3 array into a 3x2 array.
  48          *
  49          * @param   array    array to rotate
  50          * @param   boolean  keep the keys in the final rotated array. the sub arrays of the source array need to have the same key values.
  51          *                   if your subkeys might not match, you need to pass FALSE here!
  52          * @return  array
  53          */
  54         public static function rotate($source_array, $keep_keys = TRUE)
  55         {
  56                 $new_array = array();
  57                 foreach ($source_array as $key => $value)
  58                 {
  59                         $value = ($keep_keys === TRUE) ? $value : array_values($value);
  60                         foreach ($value as $k => $v)
  61                         {
  62                                 $new_array[$k][$key] = $v;
  63                         }
  64                 }
  65
  66                 return $new_array;
  67         }
  68
  69         /**
  70          * Removes a key from an array and returns the value.
  71          *
  72          * @param   string  key to return
  73          * @param   array   array to work on
  74          * @return  mixed   value of the requested array key
  75          */
  76         public static function remove($key, & $array)
  77         {
  78                 if ( ! array_key_exists($key, $array))
  79                         return NULL;
  80
  81                 $val = $array[$key];
  82                 unset($array[$key]);
  83
  84                 return $val;
  85         }
  86
  87
  88         /**
  89          * Extract one or more keys from an array. Each key given after the first
  90          * argument (the array) will be extracted. Keys that do not exist in the
  91          * search array will be NULL in the extracted data.
  92          *
  93          * @param   array   array to search
  94          * @param   string  key name
  95          * @return  array
  96          */
  97         public static function extract(array $search, $keys)
  98         {
  99                 // Get the keys, removing the $search array
 100                 $keys = array_slice(func_get_args(), 1);
 101
 102                 $found = array();
 103                 foreach ($keys as $key)
 104                 {
 105                         if (isset($search[$key]))
 106                         {
 107                                 $found[$key] = $search[$key];
 108                         }
 109                         else
 110                         {
 111                                 $found[$key] = NULL;
 112                         }
 113                 }
 114
 115                 return $found;
 116         }
 117
 118         /**
 119          * Because PHP does not have this function.
 120          *
 121          * @param   array   array to unshift
 122          * @param   string  key to unshift
 123          * @param   mixed   value to unshift
 124          * @return  array
 125          */
 126         public static function unshift_assoc( array & $array, $key, $val)
 127         {
 128                 $array = array_reverse($array, TRUE);
 129                 $array[$key] = $val;
 130                 $array = array_reverse($array, TRUE);
 131
 132                 return $array;
 133         }
 134
 135         /**
 136          * Because PHP does not have this function, and array_walk_recursive creates
 137          * references in arrays and is not truly recursive.
 138          *
 139          * @param   mixed  callback to apply to each member of the array
 140          * @param   array  array to map to
 141          * @return  array
 142          */
 143         public static function map_recursive($callback, array $array)
 144         {
 145                 foreach ($array as $key => $val)
 146                 {
 147                         // Map the callback to the key
 148                         $array[$key] = is_array($val) ? arr::map_recursive($callback, $val) : call_user_func($callback, $val);
 149                 }
 150
 151                 return $array;
 152         }
 153
 154         /**
 155          * Binary search algorithm.
 156          *
 157          * @param   mixed    the value to search for
 158          * @param   array    an array of values to search in
 159          * @param   boolean  return false, or the nearest value
 160          * @param   mixed    sort the array before searching it
 161          * @return  integer
 162          */
 163         public static function binary_search($needle, $haystack, $nearest = FALSE, $sort = FALSE)
 164         {
 165                 if ($sort === TRUE)
 166                 {
 167                         sort($haystack);
 168                 }
 169
 170                 $high = count($haystack);
 171                 $low = 0;
 172
 173                 while ($high - $low > 1)
 174                 {
 175                         $probe = ($high + $low) / 2;
 176                         if ($haystack[$probe] < $needle)
 177                         {
 178                                 $low = $probe;
 179                         }
 180                         else
 181                         {
 182                                 $high = $probe;
 183                         }
 184                 }
 185
 186                 if ($high == count($haystack) OR $haystack[$high] != $needle)
 187                 {
 188                         if ($nearest === FALSE)
 189                                 return FALSE;
 190
 191                         // return the nearest value
 192                         $high_distance = $haystack[ceil($low)] - $needle;
 193                         $low_distance = $needle - $haystack[floor($low)];
 194
 195                         return ($high_distance >= $low_distance) ? $haystack[ceil($low)] : $haystack[floor($low)];
 196                 }
 197
 198                 return $high;
 199         }
 200
 201         /**
 202          * Emulates array_merge_recursive, but appends numeric keys and replaces
 203          * associative keys, instead of appending all keys.
 204          *
 205          * @param   array  any number of arrays
 206          * @return  array
 207          */
 208         public static function merge()
 209         {
 210                 $total = func_num_args();
 211
 212                 $result = array();
 213                 for ($i = 0; $i < $total; $i++)
 214                 {
 215                         foreach (func_get_arg($i) as $key => $val)
 216                         {
 217                                 if (isset($result[$key]))
 218                                 {
 219                                         if (is_array($val))
 220                                         {
 221                                                 // Arrays are merged recursively
 222                                                 $result[$key] = arr::merge($result[$key], $val);
 223                                         }
 224                                         elseif (is_int($key))
 225                                         {
 226                                                 // Indexed arrays are appended
 227                                                 array_push($result, $val);
 228                                         }
 229                                         else
 230                                         {
 231                                                 // Associative arrays are replaced
 232                                                 $result[$key] = $val;
 233                                         }
 234                                 }
 235                                 else
 236                                 {
 237                                         // New values are added
 238                                         $result[$key] = $val;
 239                                 }
 240                         }
 241                 }
 242
 243                 return $result;
 244         }
 245
 246         /**
 247          * Overwrites an array with values from input array(s).
 248          * Non-existing keys will not be appended!
 249          *
 250          * @param   array   key array
 251          * @param   array   input array(s) that will overwrite key array values
 252          * @return  array
 253          */
 254         public static function overwrite($array1)
 255         {
 256                 foreach (array_slice(func_get_args(), 1) as $array2)
 257                 {
 258                         foreach ($array2 as $key => $value)
 259                         {
 260                                 if (array_key_exists($key, $array1))
 261                                 {
 262                                         $array1[$key] = $value;
 263                                 }
 264                         }
 265                 }
 266
 267                 return $array1;
 268         }
 269
 270         /**
 271          * Fill an array with a range of numbers.
 272          *
 273          * @param   integer  stepping
 274          * @param   integer  ending number
 275          * @return  array
 276          */
 277         public static function range($step = 10, $max = 100)
 278         {
 279                 if ($step < 1)
 280                         return array();
 281
 282                 $array = array();
 283                 for ($i = $step; $i <= $max; $i += $step)
 284                 {
 285                         $array[$i] = $i;
 286                 }
 287
 288                 return $array;
 289         }
 290
 291         /**
 292          * Recursively convert an array to an object.
 293          *
 294          * @param   array   array to convert
 295          * @return  object
 296          */
 297         public static function to_object(array $array, $class = 'stdClass')
 298         {
 299                 $object = new $class;
 300
 301                 foreach ($array as $key => $value)
 302                 {
 303                         if (is_array($value))
 304                         {
 305                                 // Convert the array to an object
 306                                 $value = arr::to_object($value, $class);
 307                         }
 308
 309                         // Add the value to the object
 310                         $object->{$key} = $value;
 311                 }
 312
 313                 return $object;
 314         }
 315
 316 } // End arr