ArrayUtils::arrayDiffAssocRecursive() - Code Metrics - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

ArrayUtils::arrayDiffAssocRecursive() D
last analyzed 2016-11-13 17:42 UTC

↳ Parent: ArrayUtils

Complexity

Conditions	9
Paths	10

Size

Total Lines	29
Code Lines	19

Duplication

Lines	8
Ratio	27.59 %

Importance

Changes

Metric	Value
cc	9
eloc	19
nc	10
nop	1
dl	8
loc	29
rs	4.909
c	0
b	0
f	0

<?php
/**
 * Methods to play with arrays.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 */

/**
 * A collection of static methods to play with arrays.
 *
 * @since 1.21
 */
class ArrayUtils {
	/**
	 * Sort the given array in a pseudo-random order which depends only on the
	 * given key and each element value in $array. This is typically used for load
	 * balancing between servers each with a local cache.
	 *
	 * Keys are preserved. The input array is modified in place.
	 *
	 * Note: Benchmarking on PHP 5.3 and 5.4 indicates that for small
	 * strings, md5() is only 10% slower than hash('joaat',...) etc.,
	 * since the function call overhead dominates. So there's not much
	 * justification for breaking compatibility with installations
	 * compiled with ./configure --disable-hash.
	 *
	 * @param array $array Array to sort
	 * @param string $key
	 * @param string $separator A separator used to delimit the array elements and the
	 *     key. This can be chosen to provide backwards compatibility with
	 *     various consistent hash implementations that existed before this
	 *     function was introduced.
	 */
	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] );
		} );
	}

	/**
	 * Given an array of non-normalised probabilities, this function will select
	 * an element and return the appropriate key
	 *
	 * @param array $weights
	 * @return bool|int|string
	 */
	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;
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
	}

	/**
	 * Do a binary search, and return the index of the largest item that sorts
	 * less than or equal to the target value.
	 *
	 * @since 1.23
	 *
	 * @param callable $valueCallback A function to call to get the value with
	 *     a given array index.
	 * @param int $valueCount The number of items accessible via $valueCallback,
	 *     indexed from 0 to $valueCount - 1
	 * @param callable $comparisonCallback A callback to compare two values, returning
	 *     -1, 0 or 1 in the style of strcmp().
	 * @param string $target The target value to find.
	 *
	 * @return int|bool The item index of the lower bound, or false if the target value
	 *     sorts before all items.
	 */
	public static function findLowerBound( $valueCallback, $valueCount,
		$comparisonCallback, $target
	) {
		if ( $valueCount === 0 ) {
			return false;
		}

		$min = 0;
		$max = $valueCount;
		do {
			$mid = $min + ( ( $max - $min ) >> 1 );
			$item = call_user_func( $valueCallback, $mid );
			$comparison = call_user_func( $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 = call_user_func( $valueCallback, $min );
			$comparison = call_user_func( $comparisonCallback, $target, $item );
			if ( $comparison < 0 ) {
				// Before the first item
				return false;
			}
		}
		return $min;
	}

	/**
	 * Do array_diff_assoc() on multi-dimensional arrays.
	 *
	 * Note: empty arrays are removed.
	 *
	 * @since 1.23
	 *
	 * @param array $array1 The array to compare from
	 * @param array $array2,... More arrays to compare against
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @return array An array containing all the values from array1
	 *               that are not present in any of the other arrays.
	 */
	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 = call_user_func_array( __METHOD__, $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;
	}
}


1		<?php
2		/**
3		* Methods to play with arrays.
4		*
5		* This program is free software; you can redistribute it and/or modify
6		* it under the terms of the GNU General Public License as published by
7		* the Free Software Foundation; either version 2 of the License, or
8		* (at your option) any later version.
9		*
10		* This program is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU General Public License for more details.
14		*
15		* You should have received a copy of the GNU General Public License along
16		* with this program; if not, write to the Free Software Foundation, Inc.,
17		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18		* http://www.gnu.org/copyleft/gpl.html
19		*
20		* @file
21		*/
22
23		/**
24		* A collection of static methods to play with arrays.
25		*
26		* @since 1.21
27		*/
28		class ArrayUtils {
29		/**
30		* Sort the given array in a pseudo-random order which depends only on the
31		* given key and each element value in $array. This is typically used for load
32		* balancing between servers each with a local cache.
33		*
34		* Keys are preserved. The input array is modified in place.
35		*
36		* Note: Benchmarking on PHP 5.3 and 5.4 indicates that for small
37		* strings, md5() is only 10% slower than hash('joaat',...) etc.,
38		* since the function call overhead dominates. So there's not much
39		* justification for breaking compatibility with installations
40		* compiled with ./configure --disable-hash.
41		*
42		* @param array $array Array to sort
43		* @param string $key
44		* @param string $separator A separator used to delimit the array elements and the
45		* key. This can be chosen to provide backwards compatibility with
46		* various consistent hash implementations that existed before this
47		* function was introduced.
48		*/
49		public static function consistentHashSort( &$array, $key, $separator = "\000" ) {
50		$hashes = [];
51		foreach ( $array as $elt ) {
52		$hashes[$elt] = md5( $elt . $separator . $key );
53		}
54		uasort( $array, function ( $a, $b ) use ( $hashes ) {
55		return strcmp( $hashes[$a], $hashes[$b] );
56		} );
57		}
58
59		/**
60		* Given an array of non-normalised probabilities, this function will select
61		* an element and return the appropriate key
62		*
63		* @param array $weights
64		* @return bool\|int\|string
65		*/
66		public static function pickRandom( $weights ) {
67		if ( !is_array( $weights ) \|\| count( $weights ) == 0 ) {
68		return false;
69		}
70
71		$sum = array_sum( $weights );
72		if ( $sum == 0 ) {
73		# No loads on any of them
74		# In previous versions, this triggered an unweighted random selection,
75		# but this feature has been removed as of April 2006 to allow for strict
76		# separation of query groups.
77		return false;
78		}
79		$max = mt_getrandmax();
80		$rand = mt_rand( 0, $max ) / $max * $sum;
81
82		$sum = 0;
83		foreach ( $weights as $i => $w ) {
84		$sum += $w;
85		# Do not return keys if they have 0 weight.
86		# Note that the "all 0 weight" case is handed above
87		if ( $w > 0 && $sum >= $rand ) {
88		break;
89		}
90		}
91
92		return $i;
		0 ignored issues – show Bug introduced 2016-02-23 18:13 UTC by Report Bug Copy Issue Report The variable `$i` seems to be defined by a `foreach` iteration on line `83`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history...
93		}
94
95		/**
96		* Do a binary search, and return the index of the largest item that sorts
97		* less than or equal to the target value.
98		*
99		* @since 1.23
100		*
101		* @param callable $valueCallback A function to call to get the value with
102		* a given array index.
103		* @param int $valueCount The number of items accessible via $valueCallback,
104		* indexed from 0 to $valueCount - 1
105		* @param callable $comparisonCallback A callback to compare two values, returning
106		* -1, 0 or 1 in the style of strcmp().
107		* @param string $target The target value to find.
108		*
109		* @return int\|bool The item index of the lower bound, or false if the target value
110		* sorts before all items.
111		*/
112		public static function findLowerBound( $valueCallback, $valueCount,
113		$comparisonCallback, $target
114		) {
115		if ( $valueCount === 0 ) {
116		return false;
117		}
118
119		$min = 0;
120		$max = $valueCount;
121		do {
122		$mid = $min + ( ( $max - $min ) >> 1 );
123		$item = call_user_func( $valueCallback, $mid );
124		$comparison = call_user_func( $comparisonCallback, $target, $item );
125		if ( $comparison > 0 ) {
126		$min = $mid;
127		} elseif ( $comparison == 0 ) {
128		$min = $mid;
129		break;
130		} else {
131		$max = $mid;
132		}
133		} while ( $min < $max - 1 );
134
135		if ( $min == 0 ) {
136		$item = call_user_func( $valueCallback, $min );
137		$comparison = call_user_func( $comparisonCallback, $target, $item );
138		if ( $comparison < 0 ) {
139		// Before the first item
140		return false;
141		}
142		}
143		return $min;
144		}
145
146		/**
147		* Do array_diff_assoc() on multi-dimensional arrays.
148		*
149		* Note: empty arrays are removed.
150		*
151		* @since 1.23
152		*
153		* @param array $array1 The array to compare from
154		* @param array $array2,... More arrays to compare against
		0 ignored issues – show Bug introduced 2016-01-16 18:00 UTC by Report Bug Copy Issue Report There is no parameter named `$array2,...`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
155		* @return array An array containing all the values from array1
156		* that are not present in any of the other arrays.
157		*/
158		public static function arrayDiffAssocRecursive( $array1 ) {
159		$arrays = func_get_args();
160		array_shift( $arrays );
161		$ret = [];
162
163		foreach ( $array1 as $key => $value ) {
164		if ( is_array( $value ) ) {
165		$args = [ $value ];
166		foreach ( $arrays as $array ) {
167		if ( isset( $array[$key] ) ) {
168		$args[] = $array[$key];
169		}
170		}
171		$valueret = call_user_func_array( __METHOD__, $args );
172		if ( count( $valueret ) ) {
173		$ret[$key] = $valueret;
174		}
175	View Code Duplication	} else {
176		foreach ( $arrays as $array ) {
177		if ( isset( $array[$key] ) && $array[$key] === $value ) {
178		continue 2;
179		}
180		}
181		$ret[$key] = $value;
182		}
183		}
184
185		return $ret;
186		}
187		}
188

wikimedia / mediawiki

ArrayUtils::arrayDiffAssocRecursive() D last analyzed 2016-11-13 17:42 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ArrayUtils::arrayDiffAssocRecursive() D
last analyzed 2016-11-13 17:42 UTC