StatementList::clear() - Code Metrics - Inspection of "Add clear to list classes" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#649)

by no

created 2016-03-10 14:08 UTC

StatementList::clear() A

↳ Parent: StatementList

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	3
ccs	0
cts	0
cp	0
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php

namespace Wikibase\DataModel\Statement;

use ArrayIterator;
use Comparable;
use Countable;
use InvalidArgumentException;
use IteratorAggregate;
use Traversable;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Reference;
use Wikibase\DataModel\ReferenceList;
use Wikibase\DataModel\Snak\Snak;
use Wikibase\DataModel\Snak\SnakList;

/**
 * Ordered and non-unique collection of Statement objects.
 * Provides various filter operations.
 *
 * Does not do any indexing by default.
 * Does not provide complex modification functionality.
 *
 * @since 1.0
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 * @author Bene* < [email protected] >
 */
class StatementList implements IteratorAggregate, Comparable, Countable {

	/**
	 * @var Statement[]
	 */
	private $statements = array();

	/**
	 * @param Statement[]|Traversable|Statement $statements
	 * @param Statement [$statement2,...]
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $statements = array() /*...*/ ) {
		if ( $statements instanceof Statement ) {
			$statements = func_get_args();
		}

		if ( !is_array( $statements ) && !( $statements instanceof Traversable ) ) {
			throw new InvalidArgumentException( '$statements must be an array or an instance of Traversable' );
		}

		foreach ( $statements as $statement ) {
			if ( !( $statement instanceof Statement ) ) {
				throw new InvalidArgumentException( 'Every element in $statements must be an instance of Statement' );
			}

			$this->statements[] = $statement;
		}
	}

	/**
	 * Returns the property ids used by the statements.
	 * The keys of the returned array hold the serializations of the property ids.
	 *
	 * @return PropertyId[] Array indexed by property id serialization.
	 */
	public function getPropertyIds() {
		$propertyIds = array();

		foreach ( $this->statements as $statement ) {
			$propertyIds[$statement->getPropertyId()->getSerialization()] = $statement->getPropertyId();
		}

		return $propertyIds;
	}

	public function addStatement( Statement $statement ) {
		$this->statements[] = $statement;
	}

	/**
	 * @param Snak $mainSnak
	 * @param Snak[]|SnakList|null $qualifiers
	 * @param Reference[]|ReferenceList|null $references
	 * @param string|null $guid
	 */
	public function addNewStatement( Snak $mainSnak, $qualifiers = null, $references = null, $guid = null ) {
		$qualifiers = is_array( $qualifiers ) ? new SnakList( $qualifiers ) : $qualifiers;
		$references = is_array( $references ) ? new ReferenceList( $references ) : $references;

		$statement = new Statement( $mainSnak, $qualifiers, $references );
		$statement->setGuid( $guid );

		$this->addStatement( $statement );
	}

	/**
	 * @since 3.0
	 *
	 * @param string|null $guid
	 */
	public function removeStatementsWithGuid( $guid ) {
		foreach ( $this->statements as $index => $statement ) {
			if ( $statement->getGuid() === $guid ) {
				unset( $this->statements[$index] );
			}
		}

		$this->statements = array_values( $this->statements );
	}

	/**
	 * Statements that have a main snak already in the list are filtered out.
	 * The last occurrences are retained.
	 *
	 * @since 1.0
	 *
	 * @return self
	 */
	public function getWithUniqueMainSnaks() {
		$statements = array();

		foreach ( $this->statements as $statement ) {
			$statements[$statement->getMainSnak()->getHash()] = $statement;
		}

		return new self( $statements );
	}

	/**
	 * @since 3.0
	 *
	 * @param PropertyId $id
	 *
	 * @return self
	 */
	public function getByPropertyId( PropertyId $id ) {
		$statementList = new self();

		foreach ( $this->statements as $statement ) {
			if ( $statement->getPropertyId()->equals( $id ) ) {
				$statementList->addStatement( $statement );
			}
		}

		return $statementList;
	}

	/**
	 * @since 3.0
	 *
	 * @param int|int[] $acceptableRanks
	 *
	 * @return self
	 */
	public function getByRank( $acceptableRanks ) {
		$acceptableRanks = array_flip( (array)$acceptableRanks );
		$statementList = new self();

		foreach ( $this->statements as $statement ) {
			if ( array_key_exists( $statement->getRank(), $acceptableRanks ) ) {
				$statementList->addStatement( $statement );
			}
		}

		return $statementList;
	}

	/**
	 * Returns the so called "best statements".
	 * If there are preferred statements, then this is all the preferred statements.
	 * If there are no preferred statements, then this is all normal statements.
	 *
	 * @since 2.4
	 *
	 * @return self
	 */
	public function getBestStatements() {
		$statements = $this->getByRank( Statement::RANK_PREFERRED );

		if ( !$statements->isEmpty() ) {
			return $statements;
		}

		return $this->getByRank( Statement::RANK_NORMAL );
	}

	/**
	 * Returns a list of all Snaks on this StatementList. This includes at least the main snaks of
	 * all statements, the snaks from qualifiers, and the snaks from references.
	 *
	 * This is a convenience method for use in code that needs to operate on all snaks, e.g.
	 * to find all referenced Entities.
	 *
	 * @since 1.1
	 *
	 * @return Snak[] Numerically indexed (non-sparse) array.
	 */
	public function getAllSnaks() {
		$snaks = array();

		foreach ( $this->statements as $statement ) {
			foreach ( $statement->getAllSnaks() as $snak ) {
				$snaks[] = $snak;
			}
		}

		return $snaks;
	}

	/**
	 * @since 2.3
	 *
	 * @return Snak[] Numerically indexed (non-sparse) array.
	 */
	public function getMainSnaks() {
		$snaks = array();

		foreach ( $this->statements as $statement ) {
			$snaks[] = $statement->getMainSnak();
		}

		return $snaks;
	}

	/**
	 * @return Traversable|Statement[]
	 */
	public function getIterator() {
		return new ArrayIterator( $this->statements );
	}

	/**
	 * @return Statement[] Numerically indexed (non-sparse) array.
	 */
	public function toArray() {
		return $this->statements;
	}

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

	/**
	 * @see Comparable::equals
	 *
	 * @param mixed $target
	 *
	 * @return bool
	 */
	public function equals( $target ) {
		if ( $this === $target ) {
			return true;
		}

		if ( !( $target instanceof self )
			|| $this->count() !== $target->count()
		) {
			return false;
		}

		return $this->statementsEqual( $target->statements );
	}

	private function statementsEqual( array $statements ) {
		reset( $statements );

		foreach ( $this->statements as $statement ) {
			if ( !$statement->equals( current( $statements ) ) ) {
				return false;
			}

			next( $statements );
		}

		return true;
	}

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

	/**
	 * @since 3.0
	 * @see StatementByGuidMap
	 *
	 * @param string|null $statementGuid
	 *
	 * @return Statement|null The first statement with the given GUID or null if not found.
	 */
	public function getFirstStatementWithGuid( $statementGuid ) {
		foreach ( $this->statements as $statement ) {
			if ( $statement->getGuid() === $statementGuid ) {
				return $statement;
			}
		}

		return null;
	}

	/**
	 * @since 4.1
	 *
	 * @param StatementFilter $filter
	 *
	 * @return self
	 */
	public function filter( StatementFilter $filter ) {
		$statementList = new self();

		foreach ( $this->statements as $statement ) {
			if ( $filter->statementMatches( $statement ) ) {
				$statementList->addStatement( $statement );
			}
		}

		return $statementList;
	}

	/**
	 * Removes all statements from this list.
	 *
	 * @since 6.0
	 */
	public function clear() {
		$this->statements = array();
	}

	/**
	 * @see http://php.net/manual/en/language.oop5.cloning.php
	 *
	 * @since 5.1
	 */
	public function __clone() {
		foreach ( $this->statements as &$statement ) {
			$statement = clone $statement;
		}
	}

}


1		<?php
2
3		namespace Wikibase\DataModel\Statement;
4
5		use ArrayIterator;
6		use Comparable;
7		use Countable;
8		use InvalidArgumentException;
9		use IteratorAggregate;
10		use Traversable;
11		use Wikibase\DataModel\Entity\PropertyId;
12		use Wikibase\DataModel\Reference;
13		use Wikibase\DataModel\ReferenceList;
14		use Wikibase\DataModel\Snak\Snak;
15		use Wikibase\DataModel\Snak\SnakList;
16
17		/**
18		* Ordered and non-unique collection of Statement objects.
19		* Provides various filter operations.
20		*
21		* Does not do any indexing by default.
22		* Does not provide complex modification functionality.
23		*
24		* @since 1.0
25		*
26		* @licence GNU GPL v2+
27		* @author Jeroen De Dauw < [email protected] >
28		* @author Bene* < [email protected] >
29		*/
30		class StatementList implements IteratorAggregate, Comparable, Countable {
31
32		/**
33		* @var Statement[]
34		*/
35		private $statements = array();
36
37		/**
38		* @param Statement[]\|Traversable\|Statement $statements
39		* @param Statement [$statement2,...]
40		*
41		* @throws InvalidArgumentException
42		*/
43	50	public function __construct( $statements = array() /.../ ) {
44	50	if ( $statements instanceof Statement ) {
45	32	$statements = func_get_args();
46	32	}
47
48	50	if ( !is_array( $statements ) && !( $statements instanceof Traversable ) ) {
49	1	throw new InvalidArgumentException( '$statements must be an array or an instance of Traversable' );
50		}
51
52	49	foreach ( $statements as $statement ) {
53	38	if ( !( $statement instanceof Statement ) ) {
54	2	throw new InvalidArgumentException( 'Every element in $statements must be an instance of Statement' );
55		}
56
57	38	$this->statements[] = $statement;
58	49	}
59	47	}
60
61		/**
62		* Returns the property ids used by the statements.
63		* The keys of the returned array hold the serializations of the property ids.
64		*
65		* @return PropertyId[] Array indexed by property id serialization.
66		*/
67	2	public function getPropertyIds() {
68	2	$propertyIds = array();
69
70	2	foreach ( $this->statements as $statement ) {
71	1	$propertyIds[$statement->getPropertyId()->getSerialization()] = $statement->getPropertyId();
72	2	}
73
74	2	return $propertyIds;
75		}
76
77	11	public function addStatement( Statement $statement ) {
78	11	$this->statements[] = $statement;
79	11	}
80
81		/**
82		* @param Snak $mainSnak
83		* @param Snak[]\|SnakList\|null $qualifiers
84		* @param Reference[]\|ReferenceList\|null $references
85		* @param string\|null $guid
86		*/
87	7	public function addNewStatement( Snak $mainSnak, $qualifiers = null, $references = null, $guid = null ) {
88	7	$qualifiers = is_array( $qualifiers ) ? new SnakList( $qualifiers ) : $qualifiers;
89	7	$references = is_array( $references ) ? new ReferenceList( $references ) : $references;
90
91	7	$statement = new Statement( $mainSnak, $qualifiers, $references );
92	7	$statement->setGuid( $guid );
93
94	7	$this->addStatement( $statement );
95	7	}
96
97		/**
98		* @since 3.0
99		*
100		* @param string\|null $guid
101		*/
102	4	public function removeStatementsWithGuid( $guid ) {
103	4	foreach ( $this->statements as $index => $statement ) {
104	4	if ( $statement->getGuid() === $guid ) {
105	3	unset( $this->statements[$index] );
106	3	}
107	4	}
108
109	4	$this->statements = array_values( $this->statements );
110	4	}
111
112		/**
113		* Statements that have a main snak already in the list are filtered out.
114		* The last occurrences are retained.
115		*
116		* @since 1.0
117		*
118		* @return self
119		*/
120	1	public function getWithUniqueMainSnaks() {
121	1	$statements = array();
122
123	1	foreach ( $this->statements as $statement ) {
124	1	$statements[$statement->getMainSnak()->getHash()] = $statement;
125	1	}
126
127	1	return new self( $statements );
128		}
129
130		/**
131		* @since 3.0
132		*
133		* @param PropertyId $id
134		*
135		* @return self
136		*/
137	2	public function getByPropertyId( PropertyId $id ) {
138	2	$statementList = new self();
139
140	2	foreach ( $this->statements as $statement ) {
141	2	if ( $statement->getPropertyId()->equals( $id ) ) {
142	1	$statementList->addStatement( $statement );
143	1	}
144	2	}
145
146	2	return $statementList;
147		}
148
149		/**
150		* @since 3.0
151		*
152		* @param int\|int[] $acceptableRanks
153		*
154		* @return self
155		*/
156	6	public function getByRank( $acceptableRanks ) {
157	6	$acceptableRanks = array_flip( (array)$acceptableRanks );
158	6	$statementList = new self();
159
160	6	foreach ( $this->statements as $statement ) {
161	4	if ( array_key_exists( $statement->getRank(), $acceptableRanks ) ) {
162	3	$statementList->addStatement( $statement );
163	3	}
164	6	}
165
166	6	return $statementList;
167		}
168
169		/**
170		* Returns the so called "best statements".
171		* If there are preferred statements, then this is all the preferred statements.
172		* If there are no preferred statements, then this is all normal statements.
173		*
174		* @since 2.4
175		*
176		* @return self
177		*/
178	4	public function getBestStatements() {
179	4	$statements = $this->getByRank( Statement::RANK_PREFERRED );
180
181	4	if ( !$statements->isEmpty() ) {
182	1	return $statements;
183		}
184
185	3	return $this->getByRank( Statement::RANK_NORMAL );
186		}
187
188		/**
189		* Returns a list of all Snaks on this StatementList. This includes at least the main snaks of
190		* all statements, the snaks from qualifiers, and the snaks from references.
191		*
192		* This is a convenience method for use in code that needs to operate on all snaks, e.g.
193		* to find all referenced Entities.
194		*
195		* @since 1.1
196		*
197		* @return Snak[] Numerically indexed (non-sparse) array.
198		*/
199	1	public function getAllSnaks() {
200	1	$snaks = array();
201
202	1	foreach ( $this->statements as $statement ) {
203	1	foreach ( $statement->getAllSnaks() as $snak ) {
204	1	$snaks[] = $snak;
205	1	}
206	1	}
207
208	1	return $snaks;
209		}
210
211		/**
212		* @since 2.3
213		*
214		* @return Snak[] Numerically indexed (non-sparse) array.
215		*/
216	1	public function getMainSnaks() {
217	1	$snaks = array();
218
219	1	foreach ( $this->statements as $statement ) {
220	1	$snaks[] = $statement->getMainSnak();
221	1	}
222
223	1	return $snaks;
224		}
225
226		/**
227		* @return Traversable\|Statement[]
228		*/
229	1	public function getIterator() {
230	1	return new ArrayIterator( $this->statements );
231		}
232
233		/**
234		* @return Statement[] Numerically indexed (non-sparse) array.
235		*/
236	4	public function toArray() {
237	4	return $this->statements;
238		}
239
240		/**
241		* @see Countable::count
242		*
243		* @return int
244		*/
245	12	public function count() {
246	12	return count( $this->statements );
247		}
248
249		/**
250		* @see Comparable::equals
251		*
252		* @param mixed $target
253		*
254		* @return bool
255		*/
256	8	public function equals( $target ) {
257	8	if ( $this === $target ) {
258		return true;
259		}
260
261	8	if ( !( $target instanceof self )
262	8	\|\| $this->count() !== $target->count()
263	8	) {
264	2	return false;
265		}
266
267	6	return $this->statementsEqual( $target->statements );
268		}
269
270	6	private function statementsEqual( array $statements ) {
271	6	reset( $statements );
272
273	6	foreach ( $this->statements as $statement ) {
274	5	if ( !$statement->equals( current( $statements ) ) ) {
275	3	return false;
276		}
277
278	5	next( $statements );
279	6	}
280
281	3	return true;
282		}
283
284		/**
285		* @return bool
286		*/
287	6	public function isEmpty() {
288	6	return empty( $this->statements );
289		}
290
291		/**
292		* @since 3.0
293		* @see StatementByGuidMap
294		*
295		* @param string\|null $statementGuid
296		*
297		* @return Statement\|null The first statement with the given GUID or null if not found.
298		*/
299	5	public function getFirstStatementWithGuid( $statementGuid ) {
300	5	foreach ( $this->statements as $statement ) {
301	3	if ( $statement->getGuid() === $statementGuid ) {
302	3	return $statement;
303		}
304	4	}
305
306	2	return null;
307		}
308
309		/**
310		* @since 4.1
311		*
312		* @param StatementFilter $filter
313		*
314		* @return self
315		*/
316	1	public function filter( StatementFilter $filter ) {
317	1	$statementList = new self();
318
319	1	foreach ( $this->statements as $statement ) {
320	1	if ( $filter->statementMatches( $statement ) ) {
321	1	$statementList->addStatement( $statement );
322	1	}
323	1	}
324
325	1	return $statementList;
326		}
327
328		/**
329		* Removes all statements from this list.
330		*
331		* @since 6.0
332		*/
333		public function clear() {
334		$this->statements = array();
335		}
336
337		/**
338		* @see http://php.net/manual/en/language.oop5.cloning.php
339		*
340		* @since 5.1
341		*/
342		public function __clone() {
343		foreach ( $this->statements as &$statement ) {
344		$statement = clone $statement;
345		}
346		}
347
348		}
349

wmde / WikibaseDataModel

Pull Request — master (#649)

StatementList::clear() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like