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 ) {
        $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;
    }
 
    public static function cartesianProduct( ...$inputArrays ) {
        $numInputs = count( $inputArrays );
        if ( $numInputs === 0 ) {
            return [];
        }
 
        // Reset the internal pointers
        foreach ( $inputArrays as &$inputArray ) {
            if ( !count( $inputArray ) ) {
                return [];
            }
            reset( $inputArray );
        }
        unset( $inputArray );
 
        $outputArrays = [];
        $done = false;
        while ( !$done ) {
            // Construct the output array element
            $element = [];
            foreach ( $inputArrays as $paramIndex => $inputArray ) {
                $element[] = current( $inputArray );
            }
            $outputArrays[] = $element;
 
            // Increment the pointers starting from the least significant.
            // If the least significant rolls over back to the start of the
            // array, continue with the next most significant, and so on until
            // that stops happening. If all pointers roll over, we are done.
            $done = true;
            for ( $paramIndex = $numInputs - 1; $paramIndex >= 0; $paramIndex-- ) {
                next( $inputArrays[$paramIndex] );
                if ( key( $inputArrays[$paramIndex] ) === null ) {
                    reset( $inputArrays[$paramIndex] );
                    // continue
                } else {
                    $done = false;
                    break;
                }
            }
        }
        return $outputArrays;
    }
}