Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /joomla/utilities/array.php

Documentation is available at array.php

  1. <?php
  2. /**
  3.  * @version        $Id: array.php 6150 2007-01-02 04:53:35Z Jinx $
  4.  * @package        Joomla.Framework
  5.  * @subpackage    Utilities
  6.  * @copyright    Copyright (C) 2005 - 2007 Open Source Matters. All rights reserved.
  7.  * @license        GNU/GPL, see LICENSE.php
  8.  *  Joomla! is free software. This version may have been modified pursuant to the
  9.  *  GNU General Public License, and as distributed it includes or is derivative
  10.  *  of works licensed under the GNU General Public License or other free or open
  11.  *  source software licenses. See COPYRIGHT.php for copyright notices and
  12.  *  details.
  13.  */
  14.  
  15. /**
  16.  * JArrayHelper is an array utility class for doing all sorts of odds and ends with arrays.
  17.  *
  18.  * @static
  19.  * @author        Louis Landry <[email protected]>
  20.  * @package     Joomla.Framework
  21.  * @subpackage        Utilities
  22.  * @since        1.5
  23.  */
  24. class JArrayHelper
  25. {
  26.     /**
  27.      * Function to convert array to integer values
  28.      *
  29.      * @static
  30.      * @param    array    $array        The source array to convert
  31.      * @param    int        $default    A default value to assign if $array is not an array
  32.      * @return    array 
  33.      * @since    1.5
  34.      */
  35.     function toInteger( &$array, $default = null)
  36.     {
  37.         if (is_array($array)) {
  38.             foreach ($array as $i => $v) {
  39.                 $array[$i] = intval($v);
  40.             }
  41.         } else {
  42.             if (is_null($default)) {
  43.                 return array();
  44.             } else {
  45.                 return array($default);
  46.             }
  47.         }
  48.     }
  49.  
  50.     /**
  51.      * Utility function to map an array to a stdClass object.
  52.      *
  53.      * @static
  54.      * @param    array    $array        The array to map.
  55.      * @param    boolean    $jobject    Optionally create a JObject
  56.      * @return    object    The object mapped from the given array
  57.      * @since    1.5
  58.      */
  59.     function toObject(&$array, $toJObject = false)
  60.     {
  61.         $obj = null;
  62.         if (is_array($array))
  63.         {
  64.             $obj = $toJObject ? new JObject() : new stdClass();
  65.             foreach ($array as $k => $v)
  66.             {
  67.                 if (is_array($v)) {
  68.                     $obj->$k = JArrayHelper::toObject($v, $toJObject);
  69.                 } else {
  70.                     $obj->$k = $v;
  71.                 }
  72.             }
  73.         }
  74.         return $obj;
  75.     }
  76.  
  77.     /**
  78.      * Utility function to map an object to an array
  79.      *
  80.      * @static
  81.      * @param    object    The source object
  82.      * @param    boolean    True to recurve through multi-level objects
  83.      * @param    string    An optional regular expression to match on field names
  84.      * @return    array    The array mapped from the given object
  85.      * @since    1.5
  86.      */
  87.     function fromObject( $p_obj, $recurse = true, $regex = null )
  88.     {
  89.         $result = null;
  90.         if (is_object( $p_obj ))
  91.         {
  92.             $result = array();
  93.             foreach (get_object_vars($p_obj) as $k => $v)
  94.             {
  95.                 if ($regex)
  96.                 {
  97.                     if (!preg_match( $regex, $k ))
  98.                     {
  99.                         continue;
  100.                     }
  101.                 }
  102.                 if (is_object( $v ))
  103.                 {
  104.                     if ($recurse)
  105.                     {
  106.                         $result[$k] = JArrayHelper::fromObject( $v, $recurse, $regex );
  107.                     }
  108.                 }
  109.                 else
  110.                 {
  111.                     $result[$k] = $v;
  112.                 }
  113.             }
  114.         }
  115.         return $result;
  116.     }
  117.  
  118.     /**
  119.      * Extracts a column from an array of arrays or objects
  120.      *
  121.      * @static
  122.      * @param    array    $array    The source array
  123.      * @param    string    $index    The index of the column or name of object property
  124.      * @return    array    Column of values from the source array
  125.      * @since    1.5
  126.      */
  127.     function getColumn(&$array, $index)
  128.     {
  129.         $result = array ();
  130.  
  131.         if (is_array($array))
  132.         {
  133.             $n = count($array);
  134.             for ($i = 0; $i < $n; $i++)
  135.             {
  136.                 $item = & $array[$i];
  137.                 if (is_array($item) && isset ($item[$index])) {
  138.                     $result[] = $item[$index];
  139.                 } elseif (is_object($item) && isset ($item-> $index)) {
  140.                     $result[] = $item-> $index;
  141.                 }
  142.                 // else ignore the entry
  143.             }
  144.         }
  145.         return $result;
  146.     }
  147.  
  148.     /**
  149.      * Utility function to return a value from a named array or a specified default
  150.      *
  151.      * @static
  152.      * @param    array    $array        A named array
  153.      * @param    string    $name        The key to search for
  154.      * @param    mixed    $default    The default value to give if no key found
  155.      * @param    string    $type        Return type for the variable (INT, FLOAT, STRING, WORD, BOOLEAN, ARRAY)
  156.      * @return    mixed    The value from the source array
  157.      * @since    1.5
  158.      */
  159.     function getValue(&$array, $name, $default=null, $type='')
  160.     {
  161.         // Initialize variables
  162.         $result = null;
  163.  
  164.         if (isset ($array[$name])) {
  165.             $result = $array[$name];
  166.         }
  167.  
  168.         // Handle the default case
  169.         if ((is_null($result))) {
  170.             $result = $default;
  171.         }
  172.  
  173.         // Handle the type constraint
  174.         switch (strtoupper($type))
  175.         {
  176.             case 'INT' :
  177.             case 'INTEGER' :
  178.                 // Only use the first integer value
  179.                 @ preg_match('/-?[0-9]+/', $result, $matches);
  180.                 $result = @ (int) $matches[0];
  181.                 break;
  182.  
  183.             case 'FLOAT' :
  184.             case 'DOUBLE' :
  185.                 // Only use the first floating point value
  186.                 @ preg_match('/-?[0-9]+(\.[0-9]+)?/', $result, $matches);
  187.                 $result = @ (float) $matches[0];
  188.                 break;
  189.  
  190.             case 'BOOL' :
  191.             case 'BOOLEAN' :
  192.                 $result = (bool) $result;
  193.                 break;
  194.  
  195.             case 'ARRAY' :
  196.                 if (!is_array($result)) {
  197.                     $result = array ($result);
  198.                 }
  199.                 break;
  200.  
  201.             case 'STRING' :
  202.                 $result = (string) $result;
  203.                 break;
  204.  
  205.             case 'WORD' :
  206.                 $result = (string) preg_replace( '#\W#', '', $result );
  207.                 break;
  208.  
  209.             case 'NONE' :
  210.             default :
  211.                 // No casting necessary
  212.                 break;
  213.         }
  214.         return $result;
  215.     }
  216.  
  217.     /**
  218.      * Utility function to sort an array of objects on a given field
  219.      *
  220.      * @static
  221.      * @param    array    $arr        An array of objects
  222.      * @param    string    $k            The key to sort on
  223.      * @param    int        $direction    Direction to sort in [1 = Ascending] [-1 = Descending]
  224.      * @return    array    The sorted array of objects
  225.      * @since    1.5
  226.      */
  227.     function sortObjects( &$a, $k, $direction=1 )
  228.     {
  229.         $GLOBALS['JAH_so'] = array(
  230.             'key'        => $k,
  231.             'direction'    => $direction
  232.         );
  233.         usort( $a, array('JArrayHelper', '_sortObjects') );
  234.         unset( $GLOBALS['JAH_so'] );
  235.  
  236.         return $a;
  237.     }
  238.  
  239.     /**
  240.      * Private callback function for sorting an array of objects on a key
  241.      *
  242.      * @static
  243.      * @param    array    $a    An array of objects
  244.      * @param    array    $b    An array of objects
  245.      * @return    int        Comparison status
  246.      * @since    1.5
  247.      * @see        JArrayHelper::sortObjects()
  248.      */
  249.     function _sortObjects( &$a, &$b )
  250.     {
  251.         $params = $GLOBALS['JAH_so'];
  252.         if ( $a->$params['key'] > $b->$params['key'] ) {
  253.             return $params['direction'];
  254.         }
  255.         if ( $a->$params['key'] < $b->$params['key'] ) {
  256.             return -1 * $params['direction'];
  257.         }
  258.         return 0;
  259.     }
  260. }
  261. ?>
Documentation generated on Mon, 05 Mar 2007 20:52:23 +0000 by phpDocumentor 1.3.1