ReferenceList::equals() - Code Metrics - Inspection of "Refactor ReferenceList" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — refactor-referencelist ( 826e0b )

by Bene

created 2016-02-06 21:49 UTC

ReferenceList::equals() A

↳ Parent: ReferenceList

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	8
rs	9.4285
cc	3
eloc	5
nc	3
nop	1

<?php

namespace Wikibase\DataModel;

use ArrayIterator;
use Comparable;
use Countable;
use InvalidArgumentException;
use IteratorAggregate;
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
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 * @author H. Snater < [email protected] >
 * @author Thiemo Mättig
 * @author Bene* < [email protected] >
 */
class ReferenceList implements Comparable, Countable, IteratorAggregate {

	/**
	 * @var Reference[]
	 */
	private $references = array();

	/**
	 * @param Reference[]|Traversable $references
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $references = array() ) {
		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
	 *
	 * @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;
		}

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

	/**
	 * @since 1.1
	 *
	 * @param Snak[]|Snak $snaks
	 * @param Snak [$snak2,...]
	 *
	 * @throws InvalidArgumentException
	 */
	public function addNewReference( $snaks = array() /*...*/ ) {
		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 ) {
		array_splice( $this->references, $index, 0, array( $reference ) );
	}

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

	/**
	 * Returns the index of a reference or false if the reference could not be found.
	 *
	 * @since 0.5
	 *
	 * @param Reference $reference
	 *
	 * @return int|boolean
	 */
	public function indexOf( Reference $reference ) {
		foreach ( $this->references as $index => $ref ) {
			if ( $ref->equals( $reference ) ) {
				return $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 boolean
	 */
	public function hasReferenceHash( $referenceHash ) {
		return $this->getReference( $referenceHash ) !== null;
	}

	/**
	 * Removes the reference with the provided hash if it exists in the list.
	 *
	 * @since 0.3
	 *
	 * @param string $referenceHash	`
	 */
	public function removeReferenceHash( $referenceHash ) {
		foreach ( $this->references as $index => $reference ) {
			if ( $reference->getHash() === $referenceHash ) {
				$this->removeReferenceAtIndex( $index );
			}
		}
	}

	/**
	 * @param int $index
	 */
	private function removeReferenceAtIndex( $index ) {
		array_splice( $this->references, $index, 1 );
	}

	/**
	 * Returns the reference 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( $this->references );
	}

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

	/**
	 * @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
	 *
	 * @since 5.0
	 *
	 * @return int
	 */
	public function count() {
		return count( $this->references );
	}

	/**
	 * @see IteratorAggregate::getIterator
	 *
	 * @since 5.0
	 *
	 * @return Traversable
	 */
	public function getIterator() {
		return new ArrayIterator( $this->references );
	}

	/**
	 * @since 5.0
	 *
	 * @return Reference[]
	 */
	public function toArray() {
		return $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 Traversable;
11			use Wikibase\DataModel\Internal\MapValueHasher;
12			use Wikibase\DataModel\Snak\Snak;
13
14			/**
15			* List of Reference objects.
16			*
17			* @since 0.1
18			* Does not implement References anymore since 2.0
19			* Does not extend SplObjectStorage since 5.0
20			*
21			* @licence GNU GPL v2+
22			* @author Jeroen De Dauw < [email protected] >
23			* @author H. Snater < [email protected] >
24			* @author Thiemo Mättig
25			* @author Bene* < [email protected] >
26			*/
27			class ReferenceList implements Comparable, Countable, IteratorAggregate {
28
29			/**
30			* @var Reference[]
31			*/
32			private $references = array();
33
34			/**
35			* @param Reference[]\|Traversable $references
36			*
37			* @throws InvalidArgumentException
38			*/
39			public function __construct( $references = array() ) {
40			if ( !is_array( $references ) && !( $references instanceof Traversable ) ) {
41			throw new InvalidArgumentException( '$references must be an array or an instance of Traversable' );
42			}
43
44			foreach ( $references as $reference ) {
45			if ( !( $reference instanceof Reference ) ) {
46			throw new InvalidArgumentException( 'Every element in $references must be an instance of Reference' );
47			}
48
49			$this->addReference( $reference );
50			}
51			}
52
53			/**
54			* Adds the provided reference to the list.
55			* Empty references are ignored.
56			*
57			* @since 0.1
58			*
59			* @param Reference $reference
60			* @param int\|null $index
61			*
62			* @throws InvalidArgumentException
63			*/
64			public function addReference( Reference $reference, $index = null ) {
65			if ( $index !== null && ( !is_int( $index ) \|\| $index < 0 ) ) {
66			throw new InvalidArgumentException( '$index must be a non-negative integer or null' );
67			}
68
69			if ( $reference->isEmpty() ) {
70			return;
71			}
72
73			if ( $index === null \|\| $index >= count( $this->references ) ) {
74			// Append object to the end of the reference list.
75			$this->references[] = $reference;
76			} else {
77			$this->insertReferenceAtIndex( $reference, $index );
78			}
79			}
80
81			/**
82			* @since 1.1
83			*
84			* @param Snak[]\|Snak $snaks
85			* @param Snak [$snak2,...]
86			*
87			* @throws InvalidArgumentException
88			*/
89			public function addNewReference( $snaks = array() /.../ ) {
90			if ( $snaks instanceof Snak ) {
91			$snaks = func_get_args();
92			}
93
94			$this->addReference( new Reference( $snaks ) );
95			}
96
97			/**
98			* @param Reference $reference
99			* @param int $index
100			*/
101			private function insertReferenceAtIndex( Reference $reference, $index ) {
102			array_splice( $this->references, $index, 0, array( $reference ) );
103			}
104
105			/**
106			* Returns if the list contains a reference with the same hash as the provided reference.
107			*
108			* @since 0.1
109			*
110			* @param Reference $reference
111			*
112			* @return boolean
113			*/
114			public function hasReference( Reference $reference ) {
115			return $this->hasReferenceHash( $reference->getHash() );
116			}
117
118			/**
119			* Returns the index of a reference or false if the reference could not be found.
120			*
121			* @since 0.5
122			*
123			* @param Reference $reference
124			*
125			* @return int\|boolean
126			*/
127			public function indexOf( Reference $reference ) {
128			foreach ( $this->references as $index => $ref ) {
129			if ( $ref->equals( $reference ) ) {
130			return $index;
131			}
132			}
133
134			return false;
135			}
136
137			/**
138			* Removes the reference with the same hash as the provided reference if such a reference exists in the list.
139			*
140			* @since 0.1
141			*
142			* @param Reference $reference
143			*/
144			public function removeReference( Reference $reference ) {
145			$this->removeReferenceHash( $reference->getHash() );
146			}
147
148			/**
149			* Returns if the list contains a reference with the provided hash.
150			*
151			* @since 0.3
152			*
153			* @param string $referenceHash
154			*
155			* @return boolean
156			*/
157			public function hasReferenceHash( $referenceHash ) {
158			return $this->getReference( $referenceHash ) !== null;
159			}
160
161			/**
162			* Removes the reference with the provided hash if it exists in the list.
163			*
164			* @since 0.3
165			*
166			* @param string $referenceHash `
167			*/
168			public function removeReferenceHash( $referenceHash ) {
169			foreach ( $this->references as $index => $reference ) {
170			if ( $reference->getHash() === $referenceHash ) {
171			$this->removeReferenceAtIndex( $index );
172			}
173			}
174			}
175
176			/**
177			* @param int $index
178			*/
179			private function removeReferenceAtIndex( $index ) {
180			array_splice( $this->references, $index, 1 );
181			}
182
183			/**
184			* Returns the reference with the provided hash, or
185			* null if there is no such reference in the list.
186			*
187			* @since 0.3
188			*
189			* @param string $referenceHash
190			*
191			* @return Reference\|null
192			*/
193			public function getReference( $referenceHash ) {
194			foreach ( $this->references as $reference ) {
195			if ( $reference->getHash() === $referenceHash ) {
196			return $reference;
197			}
198			}
199
200			return null;
201			}
202
203			/**
204			* @see Serializable::serialize
205			*
206			* @since 2.1
207			*
208			* @return string
209			*/
210			public function serialize() {
211			return serialize( $this->references );
212			}
213
214			/**
215			* @see Serializable::unserialize
216			*
217			* @since 2.1
218			*
219			* @param string $data
220			*/
221			public function unserialize( $data ) {
222			$this->__construct( unserialize( $data ) );
223			}
224
225			/**
226			* @since 4.4
227			*
228			* @return bool
229			*/
230			public function isEmpty() {
231			return empty( $this->references );
232			}
233
234			/**
235			* The hash is purely valuer based. Order of the elements in the array is not held into account.
236			*
237			* @since 0.3
238			*
239			* @return string
240			*/
241			public function getValueHash() {
242			$hasher = new MapValueHasher();
243			return $hasher->hash( $this->references );
244			}
245
246			/**
247			* @see Comparable::equals
248			*
249			* The comparison is done purely value based, ignoring the order of the elements in the array.
250			*
251			* @since 0.3
252			*
253			* @param mixed $target
254			*
255			* @return bool
256			*/
257			public function equals( $target ) {
258			if ( $this === $target ) {
259			return true;
260			}
261
262			return $target instanceof self
263			&& $this->getValueHash() === $target->getValueHash();
264			}
265
266			/**
267			* @see Countable::count
268			*
269			* @since 5.0
270			*
271			* @return int
272			*/
273			public function count() {
274			return count( $this->references );
275			}
276
277			/**
278			* @see IteratorAggregate::getIterator
279			*
280			* @since 5.0
281			*
282			* @return Traversable
283			*/
284			public function getIterator() {
285			return new ArrayIterator( $this->references );
286			}
287
288			/**
289			* @since 5.0
290			*
291			* @return Reference[]
292			*/
293			public function toArray() {
294			return $this->references;
295			}
296
297			}
298

wmde / WikibaseDataModel

Push — refactor-referencelist ( 826e0b )

ReferenceList::equals() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like