ReferenceList::insertReferenceAtIndex() - Code Metrics - Inspection of "WikibaseDataModel: PHP 7.4 CI fails" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — T243590 ( 74daf7 )

unknown

created 2020-05-26 07:15 UTC

ReferenceList::insertReferenceAtIndex() A

↳ Parent: ReferenceList

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.8333
c	0
b	0
f	0
cc	2
nc	2
nop	2

<?php

namespace Wikibase\DataModel;

use ArrayIterator;
use Comparable;
use Countable;
use InvalidArgumentException;
use IteratorAggregate;
use Serializable;
use Traversable;
use Wikibase\DataModel\Internal\MapValueHasher;
use Wikibase\DataModel\Snak\Snak;

/**
 * List of Reference objects.
 *
 * @since 0.1
 * Does not implement References anymore since 2.0
 * Does not extend SplObjectStorage since 5.0
 *
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < [email protected] >
 * @author H. Snater < [email protected] >
 * @author Thiemo Kreuz
 * @author Bene* < [email protected] >
 */
class ReferenceList implements Comparable, Countable, IteratorAggregate, Serializable {

	/**
	 * @var Reference[] Ordered list or references, indexed by SPL object hash.
	 */
	private $references = [];

	/**
	 * @param Reference[]|Traversable $references
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $references = [] ) {
		if ( !is_array( $references ) && !( $references instanceof Traversable ) ) {
			throw new InvalidArgumentException( '$references must be an array or an instance of Traversable' );
		}

		foreach ( $references as $reference ) {
			if ( !( $reference instanceof Reference ) ) {
				throw new InvalidArgumentException( 'Every element in $references must be an instance of Reference' );
			}

			$this->addReference( $reference );
		}
	}

	/**
	 * Adds the provided reference to the list.
	 * Empty references are ignored.
	 *
	 * @since 0.1
	 *
	 * @param Reference $reference
	 * @param int|null $index New position of the added reference, or null to append.
	 *
	 * @throws InvalidArgumentException
	 */
	public function addReference( Reference $reference, $index = null ) {
		if ( $index !== null && ( !is_int( $index ) || $index < 0 ) ) {
			throw new InvalidArgumentException( '$index must be a non-negative integer or null' );
		}

		if ( $reference->isEmpty() ) {
			return;
		}

		$splHash = spl_object_hash( $reference );

		if ( array_key_exists( $splHash, $this->references ) ) {
			return;
		}

		if ( $index === null || $index >= count( $this->references ) ) {
			// Append object to the end of the reference list.
			$this->references[$splHash] = $reference;
		} else {
			$this->insertReferenceAtIndex( $reference, $index );
		}
	}

	/**
	 * @since 1.1
	 *
	 * @param Snak[]|Snak $snaks
	 * @param Snak [$snak2,...]
	 *
	 * @throws InvalidArgumentException
	 */
	public function addNewReference( $snaks = [] /*...*/ ) {
		if ( $snaks instanceof Snak ) {
			$snaks = func_get_args();
		}

		$this->addReference( new Reference( $snaks ) );
	}

	/**
	 * @param Reference $reference
	 * @param int $index
	 */
	private function insertReferenceAtIndex( Reference $reference, $index ) {
		if ( !is_int( $index ) ) {
			throw new InvalidArgumentException( '$index must be an integer' );
		}

		$splHash = spl_object_hash( $reference );

		$this->references = array_merge(

			array_slice( $this->references, 0, $index ),
			[ $splHash => $reference ],
			array_slice( $this->references, $index )
		);
	}

	/**
	 * Returns if the list contains a reference with the same hash as the provided reference.
	 *
	 * @since 0.1
	 *
	 * @param Reference $reference
	 *
	 * @return bool
	 */
	public function hasReference( Reference $reference ) {
		return $this->hasReferenceHash( $reference->getHash() );
	}

	/**
	 * Returns the index of the Reference object or false if the Reference could not be found.
	 *
	 * @since 0.5
	 *
	 * @param Reference $reference
	 *
	 * @return int|bool
	 */
	public function indexOf( Reference $reference ) {
		$index = 0;

		foreach ( $this->references as $ref ) {
			if ( $ref === $reference ) {
				return $index;
			}

			$index++;
		}

		return false;
	}

	/**
	 * Removes the reference with the same hash as the provided reference if such a reference exists in the list.
	 *
	 * @since 0.1
	 *
	 * @param Reference $reference
	 */
	public function removeReference( Reference $reference ) {
		$this->removeReferenceHash( $reference->getHash() );
	}

	/**
	 * Returns if the list contains a reference with the provided hash.
	 *
	 * @since 0.3
	 *
	 * @param string $referenceHash
	 *
	 * @return bool
	 */
	public function hasReferenceHash( $referenceHash ) {
		return $this->getReference( $referenceHash ) !== null;
	}

	/**
	 * Looks for the first Reference object in this list with the provided hash.
	 * Removes all occurences of that object.
	 *
	 * @since 0.3
	 *
	 * @param string $referenceHash	`
	 */
	public function removeReferenceHash( $referenceHash ) {
		$reference = $this->getReference( $referenceHash );

		if ( $reference === null ) {
			return;
		}

		foreach ( $this->references as $splObjectHash => $ref ) {
			if ( $ref === $reference ) {
				unset( $this->references[$splObjectHash] );
			}
		}
	}

	/**
	 * Returns the first Reference object with the provided hash, or
	 * null if there is no such reference in the list.
	 *
	 * @since 0.3
	 *
	 * @param string $referenceHash
	 *
	 * @return Reference|null
	 */
	public function getReference( $referenceHash ) {
		foreach ( $this->references as $reference ) {
			if ( $reference->getHash() === $referenceHash ) {
				return $reference;
			}
		}

		return null;
	}

	/**
	 * @see Serializable::serialize
	 *
	 * @since 2.1
	 *
	 * @return string
	 */
	public function serialize() {
		return serialize( array_values( $this->references ) );
	}

	/**
	 * @see https://wiki.php.net/rfc/custom_object_serialization
	 *
	 * @return array
	 */
	public function __serialize() {
		return [
			'references' => array_values($this->references)
		];
	}

	/**
	 * @see https://wiki.php.net/rfc/custom_object_serialization
	 *
	 * @param array $data
	 */
	public function __unserialize(array $data) : void {
		$this->references = $data['references'];
	}

	/**
	 * @see Serializable::unserialize
	 *
	 * @since 2.1
	 *
	 * @param string $serialized
	 */
	public function unserialize( $serialized ) {
		$this->__construct( unserialize( $serialized ) );
	}

	/**
	 * @since 4.4
	 *
	 * @return bool
	 */
	public function isEmpty() {
		return empty( $this->references );
	}

	/**
	 * The hash is purely valuer based. Order of the elements in the array is not held into account.
	 *
	 * @since 0.3
	 *
	 * @return string
	 */
	public function getValueHash() {
		$hasher = new MapValueHasher();
		return $hasher->hash( $this->references );
	}

	/**
	 * @see Comparable::equals
	 *
	 * The comparison is done purely value based, ignoring the order of the elements in the array.
	 *
	 * @since 0.3
	 *
	 * @param mixed $target
	 *
	 * @return bool
	 */
	public function equals( $target ) {
		if ( $this === $target ) {
			return true;
		}

		return $target instanceof self
			&& $this->getValueHash() === $target->getValueHash();
	}

	/**
	 * @see Countable::count
	 *
	 * @return int
	 */
	public function count() {
		return count( $this->references );
	}

	/**
	 * @see IteratorAggregate::getIterator
	 *
	 * @since 5.0
	 *
	 * @return Iterator|Reference[]
	 */
	public function getIterator() {
		return new ArrayIterator( array_values( $this->references ) );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel;
4
5			use ArrayIterator;
6			use Comparable;
7			use Countable;
8			use InvalidArgumentException;
9			use IteratorAggregate;
10			use Serializable;
11			use Traversable;
12			use Wikibase\DataModel\Internal\MapValueHasher;
13			use Wikibase\DataModel\Snak\Snak;
14
15			/**
16			* List of Reference objects.
17			*
18			* @since 0.1
19			* Does not implement References anymore since 2.0
20			* Does not extend SplObjectStorage since 5.0
21			*
22			* @license GPL-2.0-or-later
23			* @author Jeroen De Dauw < [email protected] >
24			* @author H. Snater < [email protected] >
25			* @author Thiemo Kreuz
26			* @author Bene* < [email protected] >
27			*/
28			class ReferenceList implements Comparable, Countable, IteratorAggregate, Serializable {
29
30			/**
31			* @var Reference[] Ordered list or references, indexed by SPL object hash.
32			*/
33			private $references = [];
34
35			/**
36			* @param Reference[]\|Traversable $references
37			*
38			* @throws InvalidArgumentException
39			*/
40			public function __construct( $references = [] ) {
41			if ( !is_array( $references ) && !( $references instanceof Traversable ) ) {
42			throw new InvalidArgumentException( '$references must be an array or an instance of Traversable' );
43			}
44
45			foreach ( $references as $reference ) {
46			if ( !( $reference instanceof Reference ) ) {
47			throw new InvalidArgumentException( 'Every element in $references must be an instance of Reference' );
48			}
49
50			$this->addReference( $reference );
51			}
52			}
53
54			/**
55			* Adds the provided reference to the list.
56			* Empty references are ignored.
57			*
58			* @since 0.1
59			*
60			* @param Reference $reference
61			* @param int\|null $index New position of the added reference, or null to append.
62			*
63			* @throws InvalidArgumentException
64			*/
65			public function addReference( Reference $reference, $index = null ) {
66			if ( $index !== null && ( !is_int( $index ) \|\| $index < 0 ) ) {
67			throw new InvalidArgumentException( '$index must be a non-negative integer or null' );
68			}
69
70			if ( $reference->isEmpty() ) {
71			return;
72			}
73
74			$splHash = spl_object_hash( $reference );
75
76			if ( array_key_exists( $splHash, $this->references ) ) {
77			return;
78			}
79
80			if ( $index === null \|\| $index >= count( $this->references ) ) {
81			// Append object to the end of the reference list.
82			$this->references[$splHash] = $reference;
83			} else {
84			$this->insertReferenceAtIndex( $reference, $index );
85			}
86			}
87
88			/**
89			* @since 1.1
90			*
91			* @param Snak[]\|Snak $snaks
92			* @param Snak [$snak2,...]
93			*
94			* @throws InvalidArgumentException
95			*/
96			public function addNewReference( $snaks = [] /.../ ) {
97			if ( $snaks instanceof Snak ) {
98			$snaks = func_get_args();
99			}
100
101			$this->addReference( new Reference( $snaks ) );
102			}
103
104			/**
105			* @param Reference $reference
106			* @param int $index
107			*/
108			private function insertReferenceAtIndex( Reference $reference, $index ) {
109			if ( !is_int( $index ) ) {
110			throw new InvalidArgumentException( '$index must be an integer' );
111			}
112
113			$splHash = spl_object_hash( $reference );
114
115			$this->references = array_merge(
			0 ignored issues – show Documentation Bug introduced 2017-01-06 09:47 UTC by Report Bug Copy Issue Report It seems like `array_merge(array_slice(...s->references, $index))` of type `array<integer\|string,obj...e\DataModel\Reference>>` is incompatible with the declared type `array<integer,object<Wik...e\DataModel\Reference>>` of property `$references`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
116			array_slice( $this->references, 0, $index ),
117			[ $splHash => $reference ],
118			array_slice( $this->references, $index )
119			);
120			}
121
122			/**
123			* Returns if the list contains a reference with the same hash as the provided reference.
124			*
125			* @since 0.1
126			*
127			* @param Reference $reference
128			*
129			* @return bool
130			*/
131			public function hasReference( Reference $reference ) {
132			return $this->hasReferenceHash( $reference->getHash() );
133			}
134
135			/**
136			* Returns the index of the Reference object or false if the Reference could not be found.
137			*
138			* @since 0.5
139			*
140			* @param Reference $reference
141			*
142			* @return int\|bool
143			*/
144			public function indexOf( Reference $reference ) {
145			$index = 0;
146
147			foreach ( $this->references as $ref ) {
148			if ( $ref === $reference ) {
149			return $index;
150			}
151
152			$index++;
153			}
154
155			return false;
156			}
157
158			/**
159			* Removes the reference with the same hash as the provided reference if such a reference exists in the list.
160			*
161			* @since 0.1
162			*
163			* @param Reference $reference
164			*/
165			public function removeReference( Reference $reference ) {
166			$this->removeReferenceHash( $reference->getHash() );
167			}
168
169			/**
170			* Returns if the list contains a reference with the provided hash.
171			*
172			* @since 0.3
173			*
174			* @param string $referenceHash
175			*
176			* @return bool
177			*/
178			public function hasReferenceHash( $referenceHash ) {
179			return $this->getReference( $referenceHash ) !== null;
180			}
181
182			/**
183			* Looks for the first Reference object in this list with the provided hash.
184			* Removes all occurences of that object.
185			*
186			* @since 0.3
187			*
188			* @param string $referenceHash `
189			*/
190			public function removeReferenceHash( $referenceHash ) {
191			$reference = $this->getReference( $referenceHash );
192
193			if ( $reference === null ) {
194			return;
195			}
196
197			foreach ( $this->references as $splObjectHash => $ref ) {
198			if ( $ref === $reference ) {
199			unset( $this->references[$splObjectHash] );
200			}
201			}
202			}
203
204			/**
205			* Returns the first Reference object with the provided hash, or
206			* null if there is no such reference in the list.
207			*
208			* @since 0.3
209			*
210			* @param string $referenceHash
211			*
212			* @return Reference\|null
213			*/
214			public function getReference( $referenceHash ) {
215			foreach ( $this->references as $reference ) {
216			if ( $reference->getHash() === $referenceHash ) {
217			return $reference;
218			}
219			}
220
221			return null;
222			}
223
224			/**
225			* @see Serializable::serialize
226			*
227			* @since 2.1
228			*
229			* @return string
230			*/
231			public function serialize() {
232			return serialize( array_values( $this->references ) );
233			}
234
235			/**
236			* @see https://wiki.php.net/rfc/custom_object_serialization
237			*
238			* @return array
239			*/
240			public function __serialize() {
241			return [
242			'references' => array_values($this->references)
243			];
244			}
245
246			/**
247			* @see https://wiki.php.net/rfc/custom_object_serialization
248			*
249			* @param array $data
250			*/
251			public function __unserialize(array $data) : void {
252			$this->references = $data['references'];
253			}
254
255			/**
256			* @see Serializable::unserialize
257			*
258			* @since 2.1
259			*
260			* @param string $serialized
261			*/
262			public function unserialize( $serialized ) {
263			$this->__construct( unserialize( $serialized ) );
264			}
265
266			/**
267			* @since 4.4
268			*
269			* @return bool
270			*/
271			public function isEmpty() {
272			return empty( $this->references );
273			}
274
275			/**
276			* The hash is purely valuer based. Order of the elements in the array is not held into account.
277			*
278			* @since 0.3
279			*
280			* @return string
281			*/
282			public function getValueHash() {
283			$hasher = new MapValueHasher();
284			return $hasher->hash( $this->references );
285			}
286
287			/**
288			* @see Comparable::equals
289			*
290			* The comparison is done purely value based, ignoring the order of the elements in the array.
291			*
292			* @since 0.3
293			*
294			* @param mixed $target
295			*
296			* @return bool
297			*/
298			public function equals( $target ) {
299			if ( $this === $target ) {
300			return true;
301			}
302
303			return $target instanceof self
304			&& $this->getValueHash() === $target->getValueHash();
305			}
306
307			/**
308			* @see Countable::count
309			*
310			* @return int
311			*/
312			public function count() {
313			return count( $this->references );
314			}
315
316			/**
317			* @see IteratorAggregate::getIterator
318			*
319			* @since 5.0
320			*
321			* @return Iterator\|Reference[]
322			*/
323			public function getIterator() {
324			return new ArrayIterator( array_values( $this->references ) );
325			}
326
327			}
328

wmde / WikibaseDataModel

Push — T243590 ( 74daf7 )

ReferenceList::insertReferenceAtIndex() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like