StatementList::getPropertyIds() - Code Metrics - Inspection of "Add a StatementRank class" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — rankClass ( 1b9cf4...7f76c7 )

by no

created 2018-09-17 13:59 UTC

StatementList::getPropertyIds() A

↳ Parent: StatementList

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?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
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < [email protected] >
 * @author Bene* < [email protected] >
 * @author Thiemo Kreuz
 */
class StatementList implements IteratorAggregate, Comparable, Countable {

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

	/**
	 * @param Statement[]|Traversable|Statement $statements
	 * @param Statement [$statement2,...]
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $statements = [] /*...*/ ) {
		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 = [];

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

		return $propertyIds;
	}

	/**
	 * @since 1.0, setting an index is supported since 6.1
	 * @see ReferenceList::addReference
	 *
	 * @param Statement $statement
	 * @param int|null $index New position of the added statement, or null to append.
	 *
	 * @throws InvalidArgumentException
	 */
	public function addStatement( Statement $statement, $index = null ) {
		if ( $index === null ) {
			$this->statements[] = $statement;
		} elseif ( is_int( $index ) && $index >= 0 ) {
			array_splice( $this->statements, $index, 0, [ $statement ] );
		} else {
			throw new InvalidArgumentException( '$index must be a non-negative integer or null' );
		}
	}

	/**
	 * @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->statements[] = $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 = [];

		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->statements[] = $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->statements[] = $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 = [];

		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 = [];

		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->statements[] = $statement;
			}
		}

		return $statementList;
	}

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

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

wmde / WikibaseDataModel

Push — rankClass ( 1b9cf4...7f76c7 )

StatementList::getPropertyIds() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like