ArrayUtils.php

Go to the documentation of this file.

<?php
class ArrayUtils {
    public static function consistentHashSort( &$array, $key, $separator = "\000" ) {
        $hashes = [];
        foreach ( $array as $elt ) {
            $hashes[$elt] = md5( $elt . $separator . $key );
        }
        uasort( $array, function ( $a, $b ) use ( $hashes ) {
            return strcmp( $hashes[$a], $hashes[$b] );
        } );
    }
 
    public static function pickRandom( $weights ) {
        if ( !is_array( $weights ) || count( $weights ) == 0 ) {
            return false;
        }
 
        $sum = array_sum( $weights );
        if ( $sum == 0 ) {
            # No loads on any of them
            # In previous versions, this triggered an unweighted random selection,
            # but this feature has been removed as of April 2006 to allow for strict
            # separation of query groups.
            return false;
        }
        $max = mt_getrandmax();
        $rand = mt_rand( 0, $max ) / $max * $sum;
 
        $sum = 0;
        foreach ( $weights as $i => $w ) {
            $sum += $w;
            # Do not return keys if they have 0 weight.
            # Note that the "all 0 weight" case is handed above
            if ( $w > 0 && $sum >= $rand ) {
                break;
            }
        }
 
        return $i;
    }
 
    public static function findLowerBound( $valueCallback, $valueCount,
        $comparisonCallback, $target
    ) {
        if ( $valueCount === 0 ) {
            return false;
        }
 
        $min = 0;
        $max = $valueCount;
        do {
            $mid = $min + ( ( $max - $min ) >> 1 );
            $item = $valueCallback( $mid );
            $comparison = $comparisonCallback( $target, $item );
            if ( $comparison > 0 ) {
                $min = $mid;
            } elseif ( $comparison == 0 ) {
                $min = $mid;
                break;
            } else {
                $max = $mid;
            }
        } while ( $min < $max - 1 );
 
        if ( $min == 0 ) {
            $item = $valueCallback( $min );
            $comparison = $comparisonCallback( $target, $item );
            if ( $comparison < 0 ) {
                // Before the first item
                return false;
            }
        }
        return $min;
    }
 
    public static function arrayDiffAssocRecursive( $array1 ) {
        $arrays = func_get_args();
        array_shift( $arrays );
        $ret = [];
 
        foreach ( $array1 as $key => $value ) {
            if ( is_array( $value ) ) {
                $args = [ $value ];
                foreach ( $arrays as $array ) {
                    if ( isset( $array[$key] ) ) {
                        $args[] = $array[$key];
                    }
                }
                $valueret = self::arrayDiffAssocRecursive( ...$args );
                if ( count( $valueret ) ) {
                    $ret[$key] = $valueret;
                }
            } else {
                foreach ( $arrays as $array ) {
                    if ( isset( $array[$key] ) && $array[$key] === $value ) {
                        continue 2;
                    }
                }
                $ret[$key] = $value;
            }
        }
 
        return $ret;
    }
}