File Source for Arrays.class.php

<?php
/**
* For including this file you have to define the constant "CLASSPATH".
* Because every include in the framework depends on the CLASSPATH definition.
* The CLASSPATH means the relative path to the folder that contains the
* framework GilliGan.
*
* @package core
*/
if( !defined( "CLASSPATH" ) )
{
echo "<h3>You have to define the constant CLASSPATH!</h3>\r\n";
echo "Example: define( 'CLASSPATH', '../path/to/classes/' );\r\n";
exit();
}
if( defined( "LANG" ) )
/**
* Including language specific values.
*/
include_once( CLASSPATH."core/lang_spec_values/".LANG.".inc.php" );
else
{
echo "<h3>You have to define the constant LANG!</h3>\r\n";
echo "Example for german: define( 'LANG', 'de' );\r\n";
exit();
}
/**
*
*/
include_once( CLASSPATH."core/Numbers.class.php" );
/**
* Static methods to manipulate arrays.
*
* @static
* @version 0.2.97
* @package core
*
* @author Daniel PlÃ¼cken <daniel@debakel.net>
*
* @license http://www.gnu.org/copyleft/lesser.html
* GNU Lesser General Public License
* @copyright Copyright (c) 2003 Daniel PlÃ¼cken <daniel@debakel.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*/
class Arrays extends ABSTObject
{
/**
* Removes the record at $int-index.
*
* @static
* @access public
* @version 1.4
* @since 0.1.0
*
* @param integer $int Index of record to remove.
* @param array $array The array in which the record should be removed.
*
* @return array The removed index in an one dimensional array
*/
function deleteRecord( $int, &$array )
{ return array_splice ( $array, $int, 1 ); }
/**
* Searches the first record of $value. If it is found it will be removed
* else the unchanged array will be given back.
*
* @static
* @access public
* @version 1.1
* @since 0.1.0
*
* @param mixed $value The value that should be searched.
* @param array $array The array in which the record should be removed.
*
* @return array The removed index in an one dimensional array
*/
function deleteRecordValue( &$value, &$array )
{
for ( $i = 0; $i < count( $array ); $i++ )
if ( $array[$i] == $value )
{ return array_splice( $array, $i, 1 ); }
}
/**
* Returns whether an array is empty. That means every record of the array
* will be proofed with the function empty().
*
* @static
* @access public
* @version 1.21
* @since 0.2.0
*
* @param array $array The array that should be checked of emptiness.
*
* @return boolean
*/
function is_empty( &$array )
{
if ( !is_array( $array ) )
{ return empty( $array ); }
else
{
foreach ( $array as $key => $val )
if ( !Arrays::is_empty( $array[$key] ) )
{ return false; }
return true;
}
}
/**
* Returns the given array as an index based array.
*
* @static
* @access public
* @version 1.0
* @since 0.2.1
*
* @param array $array The array that should be converted.
*
* @return array
*/
function assoc2index( &$array )
{
if ( !is_array( $array ) )
{ return $array; }
else
while ( list( $key, $val ) = each( $array ) )
{ $tmpArr[] = Arrays::assoc2index( $val ); }
return $tmpArr;
}
/**
* Returns a new array with the values from the given key of the second
* dimension as keys in first dimension refering to the second dimension
* tuple.
*
* <code>
* $data_arr = array(
* 0 => array("id"=>24,"name"=>"Vera","name"=>"OberkÃ¶nig"),
* 1 => array("id"=>17,"name"=>"Daniel","name"=>"PlÃ¼cken"),
* 2 => array("id"=>23,"name"=>"Kayleigh","name"=>"Moritz")
* );
*
* $p_data_arr = Arrays::primaryValueToTuple( $data_arr, "id" );
*
* // now $p_data_arr is:
* $p_data_arr = array(
* "24" => array("id"=>24,"name"=>"Vera","name"=>"OberkÃ¶nig"),
* "17" => array("id"=>17,"name"=>"Daniel","name"=>"PlÃ¼cken"),
* "23" => array("id"=>23,"name"=>"Kayleigh","name"=>"Moritz")
* );
*
* </code>
*
* @static
* @access public
* @version 1.0
* @since 0.2.97
*
* @param array $array
* @param string $value_key
*
* @return array
*/
function &primaryValueToTuple( &$array, $value_key )
{
$out_arr = array();
foreach ( $array as $key => $val_arr )
{ $out_arr[ $val_arr[$value_key] ] = $array[$key]; }
return $out_arr;
}
/**
* Converts a multidimensional array in a one dimensional array.
*
* @static
* @access public
* @version 1.0
* @since 0.2.1
*
* @author bluej100 at gmail dot com
* @see http://www.php.net/manual/en/function.array-values.php#77671
* @author Daniel PlÃ¼cken <daniel@debakel.net> (some modifications)
*
* @param array $array
* @param array $newArray
* @param integer $preserve_keys
*
* @return array
*/
function &flatten( &$array, &$newArray, $preserve_keys = 1 )
{
foreach ( $array as $key => $child )
{
if ( is_array( $child[$key] ) )
{
$newArray =& Arrays::flatten(
$child[$key], $newArray, $preserve_keys
);
}
else
if ( $preserve_keys + is_string( $key ) > 1 )
{ $newArray[$key] = $child; }
else
{ $newArray[] = $child; }
}
return $newArray;
}
/**
* Returns the position of the first record that matches the value
* of $mixedVal. If there is not a record that matches the value
* then the function will return false.
*
* @static
* @access public
* @version 1.2
* @since 0.1.2
*
* @param mixed $mixedVal The value that should be searched.
* @param array $array The array in which the record should be
* searched.
*
* @return integer|false
*/
function getFirstIndexOf( &$mixedVal, &$array )
{
if (
is_object( $mixedVal )
&& method_exists ( $mixedVal, "equals" )
)
{
for ( $i = 0; $i < count( $array ); $i++ )
if ( $mixedVal->equals( $array[$i] ) )
{ return $i; }
}
else
{
for ( $i = 0; $i < count( $array ); $i++ )
if ( $array[$i] == $mixedVal )
{ return $i; }
}
return false;
}
/**
* Returns a random record of given $array. Sets automatically a new random
* set by microtime for real random.
*
* @static
* @access public
* @version 1.0
* @since 0.1.7
*
* @param array $array The array from which the record should be returned.
*
* @return array
*/
function getRandomRecord( $array )
{
$tmp = Numbers::random( 0, count( $array ) - 1 );
return $array[$tmp];
}
/**
* Returns true if $array contains $record else it will return false.
*
* @static
* @access public
* @version 1.02
* @since 0.1.5
*
* @param array $array The array in which schould be searched.
* @param mixed $record The value which should compare with the records
* of the array.
* @return boolean
*/
function contains( &$array, &$record )
{ return Arrays::getFirstIndexOf( $record, $array ) !== false; }
/**
* Fills $record in $array only if $array does not already contains it.
*
* @static
* @access public
* @version 1.01
* @since 0.1.2
*
* @param array $array The array in which the record should be filled in.
* @param mixed $record The value which should be filled in the array.
*
* @return void
*/
function uniqueInsert( &$array, $record )
{
for ( $i = 0; $i < count( $array ); $i++ )
if ( $array[$i] == $record )
{ return; }
$array[] = $record;
}
/**
* Removes doubly occuring records in $array and set up new indexes, so that
* the first index of the array beginns at zero and the other indexes
* following integrated and ascendending.
*
* @static
* @access public
* @version 1.0
* @since 0.1.4
*
* @param array $array The array in which each record should be unique.
*
* @return array
*/
function uniqueRecords( &$array )
{
$array = array_unique( $array );
foreach( $array as $tmp )
{ $array_out[] = $tmp; }
return $array_out;
}
/**
* Returns the given second dimension index of a two dimensional array as
* a one dimensional array. Imagine that a two dimensional array is pictured
* as a table and you want to get all values from a specified col of this
* table, then you can use this function to do so. It is very helpful to
* extract all values of a field from a set of data.
*
* @static
* @access public
* @version 1.1
* @since 0.2.2
*
* @param integer/string $index
* @param array $array The array of which the index
* should be extract.
* @param boolean $empty_entries Decides wether empty entries
* should add to the new array or
* not.
*
* @return array
*/
function getIndexAsArray( $index, &$array, $empty_entries = false )
{
$arr = array();
for ( $i = 0; $i < count( $array ); $i++ )
if (
$empty_entries
|| !empty( $array[$i][$index] )
)
{ $arr[] = $array[$i][$index]; }
return $arr;
}
/**
* Returns the values behind all keys that correspond with the given one.
*
* @static
* @access public
* @version 1.0
* @since 0.2.8
*
* @param string $str_key_name
* @param array $in_arr
*
* @return array
*/
function getValuesOfKey( $str_key_name, &$in_arr )
{
$out_arr = array();
foreach ( $in_arr as $key => $value )
if ( $key === $str_key_name )
{ $out_arr[] = $value; }
else
if ( is_array( $value ) )
{
$out_arr = array_merge(
$out_arr,
Arrays::getValuesOfKey( $str_key_name, $value )
);
}
return $out_arr;
}
/**
* Returns the first occuring value that is a type of integer.
*
* @static
* @access public
* @version 1.0
* @since 0.2.8
*
* @param array $in_arr
*
* @return false|integer
*/
function getFirstIntegerValue( &$in_arr )
{
foreach ( $in_arr as $key => $value )
if ( is_int( $value ) )
{ return $value; }
else
if ( is_array( $value ) )
{ return Arrays::getFirstIntegerValue( $value ); }
return false;
}
/**
* Returns the first occuring value that matches a regular expression.
*
* @static
* @access public
* @version 1.0
* @since 0.2.8
*
* @param string $str_reg_exp
* @param array $in_arr
*
* @return false|string
*/
function getFirstPregMatchValue( $str_reg_exp, &$in_arr )
{
foreach ( $in_arr as $key => $value )
if (
!is_array( $value )
&& !is_object( $value )
&& preg_match( $str_reg_exp, $value )
)
{ return $value; }
else
if ( is_array( $value ) )
{ return Arrays::getFirstPregMatchValue( $value ); }
return false;
}
/**
* Merges two arrays to one. All records that occuring in both arrays will
* be remove.
*
* @static
* @access public
* @version 1.1
* @since 0.1.8
*
* @param array $array1
* @param array $array2
* @return array
*/
function complementArrays( &$array1, &$array2 )
{
if ( count( $array1 ) < 1 )
{ return $array2; }
if ( count( $array2 ) < 1 )
{ return $array1; }
for ( $i = 0; $i < count( $array1 ); $i++ )
{
$tempsame = false;
for ( $j = 0; $j < count( $array2 ); $j++ )
if ( $array1[$i] == $array2[$j] )
{
$tempsame = true;
break;
}
if ( !$tempsame )
{ $newArray[] = $array1[$i]; }
}
for( $i = 0; $i < count( $array2 ); $i++ )
{
$tempsame = false;
for ( $j = 0; $j < count( $array1 ); $j++ )
if ( $array2[$i] == $array1[$j] )
{
$tempsame = true;
break;
}
if ( !$tempsame )
{ $newArray[] = $array2[$i]; }
}
return $newArray;
}
/**
* Returns whether the records in the array are consecutively numbered
* in a given range after the array had been sort. This function can be
* helpful to proof the completeness of data.
*
* Example:
* <code>
* $arr = array( 3, 5, 4, 6, 7, 9, 8 );
* if( Arrays::integratedAscending( $arr, 3, 9 ) )
* echo "This will surely be output.";
*
* if( Arrays::integratedAscending( $arr, 3, 7 ) )
* echo "This will NOT be output.";
*
* $arr2 = array( 3, 5, 7, 9, 8 );
* if( Arrays::integratedAscending( $arr2, 3, 9 ) )
* echo "This will also NOT be output.";
* </code>
*
* @static
* @access public
* @version 1.0
* @since 0.1.9
*
* @param array $array The array to be probed.
* @param integer $rangeA The minimum of the range.
* @param integer $rangeB The maximum of the range.
*
* @return array
*/
function integratedAscending( $array, $rangeA, $rangeB )
{
if ( $rangeA < $rangeB )
{
$tmpmin = $rangeA;
$tmpmax = $rangeB;
}
else
{
$tmpmin = $rangeB;
$tmpmax = $rangeA;
}
sort( $array );
if (
$array[0] < $tmpmin
|| $array[count( $array ) - 1] > $tmpmax
)
{ return false; }
$j = $array[0];
for ( $i = 0; $i < count( $array ); $i++ )
{
if ( $array[$i] != $j )
{ return false; }
$j++;
}
return true;
}
/**
* Returns a string containing a string representation of all the array
* elements on index of the arrays second dimension in the same order, with
* the glue string between each element.
*
* @static
* @access public
* @version 1.0
* @since 0.2.6
*
* @param string $glue
* @param array $array The array which elements will be used.
* @param integer/string $index
* @param boolean $empty_entries Decides wether empty entries
* should add to the string or not.
* @return string
*/
function implodeIndex( $glue, &$array, $index, $empty_entries = false )
{
$out = "";
if( is_array( $array ) )
{
$k = 0;
reset( $array );
do
{ $out = $array[$k][$index]; }
while (
empty( $array[$k++][$index] )
&& !$empty_entries
&& $k < count( $array )
);
for ( $i = $k; $i < count( $array ); $i++ )
if (
$empty_entries
|| !empty( $array[$i][$index] )
)
{ $out .= $glue.$array[$i][$index]; }
}
return $out;
}
/**
* Sorts an array by a given second index. You can affect the order of
* character and strings by defining the constnand ALPHABET and
* NO_CASE_ALPHABET in the language file which can be found in the package
* core/lang_spec_values. With defining of the constant LANG, you can switch
* between the various orders on every new page request.
*
* @static
* @access public
* @version 1.0
* @since 0.2.3
*
* @param array $array The array that should be sort.
* @param string $index The index or rather name of the second dimension
* that should be sort.
* @param string $func The suffix of the custum function which should be
* used (See also the function list of the package
* core).
* Possible Values are:
* - boolcmp: To sort boolean values ascending. First cames
* false, then true.
* - boolcmp_desc: To sort boolean values descending. First
* cames true, the false.
* - charcmp: To sort character values ascending.
* The order can be dedicated by defining the
* constant ALPHABET in the language files that
* can be found in the package
* core/lang_spec_values.
* - charcmp_desc: To sort character values descending.
* The order can be dedicated by defining the
* constant ALPHABET in the language files that
* can be found in the package
* core/lang_spec_values.
* - intcmp: To sort integer values ascending.
* - intcmp_desc To sort integer values descending.
* - strcmp: To sort Strings ascending.
* The order can be dedicated by defining the
* constant ALPHABET in the language files that
* can be found in the package
* core/lang_spec_values.
* - strcmp_desc: To sort Strings descending.
* The order can be dedicated by defining the
* constant ALPHABET in the language files that
* can be found in the package
* core/lang_spec_values.
* @return array
*/
function &sortSecondDimension ( &$array, $index, $func = "strcmp" )
{
$GLOBALS["KEY2SORT"] = $index;
usort( $array, "Arrays__".$func );
return $array;
}
}// END of class Arrays
////////////////////////////////////////////////////////////////////////////////
/**
* @see http://www.php.net/manual/en/function.usort.php
*
* @static
* @version 1.0
* @since 0.2.3
* @access private
* @author gk at lka dot hu
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @param char $a
* @param char $b
* @return array
*/
function Arrays__charcmp( $a, $b )
{
if( $a == $b )
return 0;
$ALP = ALPHABET;
$ALPL = strlen( $ALP );
$ap = $bp = -1;
$i = 0;
while(
$i < $ALPL
&& (
$ap == -1
|| $bp == -1
)
)
{
if( $ALP[$i] == $a )
$ap = $i;
if( $ALP[$i] == $b )
$bp = $i;
$i++;
}
return $ap < $bp ? -1 : 1;
}
/**
* @see http://www.php.net/manual/en/function.usort.php
*
* @static
* @version 1.0
* @since 0.2.5
* @access private
* @author gk at lka dot hu
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @param char $a
* @param char $b
* @return array
*/
function Arrays__charcmp_desc( $a, $b )
{
if( $a == $b )
return 0;
$ALP = ALPHABET;
$ALPL = strlen( $ALP );
$ap = $bp = -1;
$i = 0;
while(
$i < $ALPL
&& (
$ap == -1
|| $bp == -1
)
)
{
if( $ALP[$i] == $a )
$ap = $i;
if( $ALP[$i] == $b )
$bp = $i;
$i++;
}
return $ap < $bp ? 1 : -1;
}
/**
* @see http://www.php.net/manual/en/function.usort.php
*
* @static
* @version 1.0
* @since 0.2.3
* @access private
* @author gk at lka dot hu
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @param char $a
* @param char $b
* @return array
*/
function Arrays__strcmp( $astring, $bstring )
{
if( NO_CASE_ALPHABET )
{
$tmp_a = strtolower( $astring[$GLOBALS["KEY2SORT"]] );
$tmp_b = strtolower( $bstring[$GLOBALS["KEY2SORT"]] );
//if equal
if( $tmp_a == $tmp_b )
return 0;
//do it on every element
for(
$i = 0;
$i < strlen( $astring[$GLOBALS["KEY2SORT"]] )
&& $i < strlen( $bstring[$GLOBALS["KEY2SORT"]] )
&& $tmp_a[$i] == $tmp_b[$i];
$i++
);
//if the two strings are the same, the shorter wins
if( $tmp_a[$i] == $tmp_b[$i] )
return strlen( $astring[$GLOBALS["KEY2SORT"]] )
> strlen( $bstring[$GLOBALS["KEY2SORT"]] )
? -1 : 1;
//otherwise depends on the first different char
return Arrays__charcmp( $tmp_a[$i], $tmp_b[$i] );
}
else
{
//if equal
if( $astring[$GLOBALS["KEY2SORT"]] == $bstring[$GLOBALS["KEY2SORT"]] )
return 0;
//do it on every element
for(
$i = 0;
$i < strlen( $astring[$GLOBALS["KEY2SORT"]] )
&& $i < strlen( $bstring[$GLOBALS["KEY2SORT"]] )
&& $astring[$i] == $bstring[$i];
$i++
);
//if the two strings are the same, the shorter wins
if(
$astring[ $GLOBALS["KEY2SORT"] ][$i]
== $bstring[ $GLOBALS["KEY2SORT"] ][$i]
)
return strlen( $astring[$GLOBALS["KEY2SORT"]] )
> strlen( $bstring[$GLOBALS["KEY2SORT"]] )
? -1 : 1;
//otherwise depends on the first different char
return Arrays__charcmp(
$astring[ $GLOBALS["KEY2SORT"] ][$i],
$bstring[ $GLOBALS["KEY2SORT"] ][$i]
);
}
}
/**
* @see http://www.php.net/manual/en/function.usort.php
*
* @static
* @version 1.0
* @since 0.2.5
* @access private
* @author gk at lka dot hu
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @param char $a
* @param char $b
* @return array
*/
function Arrays__strcmp_desc( $astring, $bstring )
{
if( NO_CASE_ALPHABET )
{
$tmp_a = strtolower( $astring[$GLOBALS["KEY2SORT"]] );
$tmp_b = strtolower( $bstring[$GLOBALS["KEY2SORT"]] );
//if equal
if( $tmp_a == $tmp_b )
return 0;
//do it on every element
for(
$i = 0;
$i < strlen( $astring[$GLOBALS["KEY2SORT"]] )
&& $i < strlen( $bstring[$GLOBALS["KEY2SORT"]] )
&& $tmp_a[$i] == $tmp_b[$i];
$i++
);
//if the two strings are the same, the shorter wins
if( $tmp_a[$i] == $tmp_b[$i] )
return strlen( $astring[$GLOBALS["KEY2SORT"]] )
> strlen( $bstring[$GLOBALS["KEY2SORT"]] )
? 1 : -1;
//otherwise depends on the first different char
return Arrays__charcmp_desc( $tmp_a[$i], $tmp_b[$i] );
}
else
{
//if equal
if( $astring[$GLOBALS["KEY2SORT"]] == $bstring[$GLOBALS["KEY2SORT"]] )
return 0;
//do it on every element
for(
$i = 0;
$i < strlen( $astring[$GLOBALS["KEY2SORT"]] )
&& $i < strlen( $bstring[$GLOBALS["KEY2SORT"]] )
&& $astring[$i] == $bstring[$i];
$i++
);
//if the two strings are the same, the shorter wins
if(
$astring[ $GLOBALS["KEY2SORT"] ][$i]
== $bstring[ $GLOBALS["KEY2SORT"] ][$i]
)
return strlen( $astring[$GLOBALS["KEY2SORT"]] )
> strlen( $bstring[$GLOBALS["KEY2SORT"]] )
? 1 : -1;
//otherwise depends on the first different char
return Arrays__charcmp_desc(
$astring[ $GLOBALS["KEY2SORT"] ][$i],
$bstring[ $GLOBALS["KEY2SORT"] ][$i]
);
}
}
/**
* Custom sort algorithm to sort integer.
*
* @static
* @version 1.0
* @since 0.2.4
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @access private
* @param integer $a
* @param integer $b
* @return array
*/
function Arrays__intcmp( $a, $b )
{
if( $a[$GLOBALS["KEY2SORT"]] == $b[$GLOBALS["KEY2SORT"]] )
return 0;
return $a[$GLOBALS["KEY2SORT"]] < $b[$GLOBALS["KEY2SORT"]] ? -1 : 1;
}
/**
* Custom sort algorithm to sort integer.
*
* @static
* @version 1.0
* @since 0.2.4
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @access private
* @param integer $a
* @param integer $b
* @return array
*/
function Arrays__intcmp_desc( $a, $b )
{
if( $a[$GLOBALS["KEY2SORT"]] == $b[$GLOBALS["KEY2SORT"]] )
return 0;
return $a[$GLOBALS["KEY2SORT"]] < $b[$GLOBALS["KEY2SORT"]] ? 1 : -1;
}
/**
* Custom sort algorithm to sort booleans. First false then true.
*
* @static
* @version 1.0
* @since 0.2.3
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @access private
* @param boolean $a
* @param boolean $b
* @return array
*/
function Arrays__boolcmp( $a, $b )
{
if(
$a[$GLOBALS["KEY2SORT"]] && $b[$GLOBALS["KEY2SORT"]]
|| !$a[$GLOBALS["KEY2SORT"]] && !$b[$GLOBALS["KEY2SORT"]]
)
return 0;
if( $a[$GLOBALS["KEY2SORT"]] )
return 1;
else
return -1;
}
/**
* Custom sort algorithm to sort booleans. First true then false.
*
* @static
* @version 1.0
* @since 0.2.3
* @author Daniel PlÃ¼cken <daniel@debakel.net>
* @access private
* @param boolean $a
* @param boolean $b
* @return array
*/
function Arrays__boolcmp_desc( $a, $b )
{
if(
$a[$GLOBALS["KEY2SORT"]] && $b[$GLOBALS["KEY2SORT"]]
|| !$a[$GLOBALS["KEY2SORT"]] && !$b[$GLOBALS["KEY2SORT"]]
)
return 0;
if( $a[$GLOBALS["KEY2SORT"]] )
return -1;
else
return 1;
}
?>

Source for file Arrays.class.php