FuncUtility.php - (Manipulate values in iterable data sets)


/ Published in: PHP
Save to your folder(s)

This class can be used to Manipulate values in iterable data sets.

It can iterate over a set of elements contained in a collection managed by an object that implements the Iterable interface.

The class executes several types of operations to manipulate the collection elements by invoking given callback functions that determine what to do with the elements.

Currently it can filter a subset of the elements, call a function to manipulate each of the elements, map the elements to a new set of values, reduce the elements to a single value.


Copy this code and paste it in your HTML
  1. <?php
  2. /**
  3.  * Allows to use FP-like features for arrays, strings, SPL iterators and even results
  4.  * returned from callbacks
  5.  *
  6.  * This class adds a lot of syntax sugar to your recordset processing routines or other
  7.  * similar tasks when you don't want to write a loop construct. You will never see the
  8.  * calls of FuncUtility methods in the Frontier's core. It uses call_user_func(),
  9.  * which is slow. But I hope, it's performance will be improved someday though.
  10.  *
  11.  * @author Stanis Shramko <[email protected]>
  12.  */
  13. class FuncUtility
  14. {
  15.  
  16.   /**
  17.    * Filters all elements of $set using the $callback
  18.    *
  19.    * @return array
  20.    * @throws InvalidArgumentException
  21.    */
  22.   public static function filter($callback, $set)
  23.   {
  24.     if (!is_callable($callback))
  25.     {
  26.       throw new InvalidArgumentException(
  27.         'The first argument is not callable');
  28.     }
  29.     $values = array();
  30.     if (is_callable($set))
  31.     {
  32.       while ($value = call_user_func($set))
  33.       {
  34.         if (call_user_func($callback, $value))
  35.         {
  36.           $values[] = $value;
  37.         }
  38.       }
  39.     }
  40.     else
  41.     {
  42.       foreach (($set = self::prepareIterable($set)) as $value)
  43.       {
  44.         if (call_user_func($callback, $value))
  45.           $values[] = $value;
  46.       }
  47.     }
  48.     return $values;
  49.   }
  50.  
  51.   /**
  52.    * Applies the $callback to all elements of $set
  53.    *
  54.    * @return void
  55.    * @throws InvalidArgumentException
  56.    */
  57.   public static function each($callback, $set)
  58.   {
  59.     if (!is_callable($callback))
  60.     {
  61.       throw new InvalidArgumentException(
  62.         'The first argument is not callable');
  63.     }
  64.     if (is_callable($set))
  65.     {
  66.       while ($value = call_user_func($set))
  67.       {
  68.         call_user_func($callback, $value);
  69.       }
  70.     }
  71.     else
  72.     {
  73.       foreach (($set = self::prepareIterable($set)) as $value)
  74.       {
  75.         call_user_func($callback, $value);
  76.       }
  77.     }
  78.   }
  79.  
  80.   /**
  81.    * Applies the $callback to all elements of $set
  82.    *
  83.    * @return array
  84.    * @throws InvalidArgumentException
  85.    */
  86.   public static function map($callback, $set)
  87.   {
  88.     if (!is_callable($callback))
  89.     {
  90.       throw new InvalidArgumentException(
  91.         'The first argument is not callable');
  92.     }
  93.     $values = array();
  94.     if (is_callable($set))
  95.     {
  96.       while ($value = call_user_func($set))
  97.       {
  98.         $values[] = call_user_func($callback, $value);
  99.       }
  100.     }
  101.     else
  102.     {
  103.       foreach (($set = self::prepareIterable($set)) as $value)
  104.       {
  105.         $values[] = call_user_func($callback, $value);
  106.       }
  107.     }
  108.     return $values;
  109.   }
  110.  
  111.   /**
  112.    * Reduces the $set using $result
  113.    *
  114.    * @return array
  115.    * @throws InvalidArgumentException
  116.    */
  117.   public static function reduce($callback, $set)
  118.   {
  119.     if (!is_callable($callback))
  120.     {
  121.       throw new InvalidArgumentException(
  122.         'The first argument is not callable');
  123.     }
  124.     if (is_callable($set))
  125.     {
  126.       $result = call_user_func($set);
  127.       while ($value = call_user_func($set))
  128.       {
  129.         $result = call_user_func($callback, $result, $value);
  130.       }
  131.     }
  132.     else
  133.     {
  134.       $first = true;
  135.       foreach (($set = self::prepareIterable($set)) as $value)
  136.       {
  137.         if (!$first)
  138.         {
  139.           $result = call_user_func($callback, $result,
  140.             $value);
  141.         }
  142.         else
  143.         {
  144.           $result = $value;
  145.           $first = false;
  146.         }
  147.       }
  148.     }
  149.     return $result;
  150.   }
  151.  
  152.   /**
  153.    * Prepares "something iterable"
  154.    *
  155.    * @param mixed $set
  156.    * @return mixed array or Iterator
  157.    */
  158.   protected static function prepareIterable($set)
  159.   {
  160.     if (is_array($set) || $set instanceof Iterator)
  161.     {
  162.       return $set;
  163.     }
  164.     if (is_string($set))
  165.     {
  166.       return str_split($set);
  167.     }
  168.     throw new InvalidArgumentException('The second argument is not iterable');
  169.   }
  170.  
  171. }

URL: http://www.phpclasses.org/browse/file/27467.html

Report this snippet


Comments

RSS Icon Subscribe to comments

You need to login to post a comment.