ByPropertyIdArray - Code Metrics - Inspection of "Block ByPropertyIdArray construction from object p..." - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — objectById ( 934c73 )

by no

created 2016-04-28 14:29 UTC

ByPropertyIdArray C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	451
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	6
Bugs	0	Features	2

Metric	Value
wmc	56
c	6
b	0
f	2
lcom	1
cbo	2
dl	0
loc	451
rs	6.5957

17 Methods

Rating	Name	Size	Complexity
A	__construct()	7	3
A	buildIndex()	14	3
A	assertIndexIsBuild()	5	2
A	getPropertyIds()	10	1
A	getByPropertyId()	9	2
A	getFlatArrayIndexOfObject()	12	3
A	toFlatArray()	9	2
A	getFlatArrayIndices()	17	3
B	moveObjectInPropertyGroup()	30	5
A	moveObjectToEndOfPropertyGroup()	15	2
A	removeObject()	6	1
A	insertObjectAtIndex()	11	1
C	movePropertyGroup()	47	9
A	getPropertyGroupIndex()	13	3
C	moveObjectToIndex()	27	7
B	addObjectAtIndex()	25	4
B	addObjectToPropertyGroup()	37	5

How to fix Complexity

<?php

namespace Wikibase\DataModel;

use ArrayObject;
use InvalidArgumentException;
use OutOfBoundsException;
use RuntimeException;
use Traversable;
use Wikibase\DataModel\Entity\PropertyId;

/**
 * Helper for managing objects indexed by property id.
 *
 * This is a light weight alternative approach to using something
 * like GenericArrayObject with the advantages that no extra interface
 * is needed and that indexing does not happen automatically.
 *
 * Lack of automatic indexing means that you will need to call the
 * buildIndex method before doing any look-ups.
 *
 * Since no extra interface is used, the user is responsible for only
 * adding objects that have a getPropertyId method that returns either
 * a string or integer when called with no arguments.
 *
 * Objects may be added or moved within the structure. Absolute indices (indices according to the
 * flat list of objects) may be specified to add or move objects. These management operations take
 * the property grouping into account. Adding or moving objects outside their "property groups"
 * shifts the whole group towards that index.
 *
 * Example of moving an object within its "property group":
 * o1 (p1)                           o1 (p1)
 * o2 (p2)                       /-> o3 (p2)
 * o3 (p2) ---> move to index 1 -/   o2 (p2)
 *
 * Example of moving an object that triggers moving the whole "property group":
 * o1 (p1)                       /-> o3 (p2)
 * o2 (p2)                       |   o2 (p2)
 * o3 (p2) ---> move to index 0 -/   o1 (p1)
 *
 * @since 0.2
 * @deprecated since 5.0, use a DataModel Service instead
 *
 * @license GPL-2.0+
 * @author H. Snater < [email protected] >
 */
class ByPropertyIdArray extends ArrayObject {

	/**
	 * @var array[]|null
	 */
	private $byId = null;

	/**
	 * @deprecated since 5.0, use a DataModel Service instead
	 * @see ArrayObject::__construct
	 *
	 * @param PropertyIdProvider[]|Traversable|null $input
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $input = null ) {
		if ( is_object( $input ) && !( $input instanceof Traversable ) ) {
			throw new InvalidArgumentException( '$input must be an array, Traversable or null' );
		}

		parent::__construct( (array)$input );
	}

	/**
	 * Builds the index for doing look-ups by property id.
	 *
	 * @since 0.2
	 */
	public function buildIndex() {
		$this->byId = array();

		/** @var PropertyIdProvider $object */
		foreach ( $this as $object ) {
			$propertyId = $object->getPropertyId()->getSerialization();

			if ( !array_key_exists( $propertyId, $this->byId ) ) {
				$this->byId[$propertyId] = array();
			}

			$this->byId[$propertyId][] = $object;
		}
	}

	/**
	 * Checks whether id indexed array has been generated.
	 *
	 * @throws RuntimeException
	 */
	private function assertIndexIsBuild() {
		if ( $this->byId === null ) {
			throw new RuntimeException( 'Index not build, call buildIndex first' );
		}
	}

	/**
	 * Returns the property ids used for indexing.
	 *
	 * @since 0.2
	 *
	 * @return PropertyId[]
	 * @throws RuntimeException
	 */
	public function getPropertyIds() {
		$this->assertIndexIsBuild();

		return array_map(
			function( $serializedPropertyId ) {
				return new PropertyId( $serializedPropertyId );
			},
			array_keys( $this->byId )
		);
	}

	/**
	 * Returns the objects featuring the provided property id in the index.
	 *
	 * @since 0.2
	 *
	 * @param PropertyId $propertyId
	 *
	 * @throws OutOfBoundsException
	 * @throws RuntimeException
	 * @return PropertyIdProvider[]
	 */
	public function getByPropertyId( PropertyId $propertyId ) {
		$this->assertIndexIsBuild();

		if ( !( array_key_exists( $propertyId->getSerialization(), $this->byId ) ) ) {
			throw new OutOfBoundsException( "Object with propertyId \"$propertyId\" not found" );
		}

		return $this->byId[$propertyId->getSerialization()];
	}

	/**
	 * Returns the absolute index of an object or false if the object could not be found.
	 * @since 0.5
	 *
	 * @param PropertyIdProvider $object
	 *
	 * @return bool|int
	 * @throws RuntimeException
	 */
	public function getFlatArrayIndexOfObject( $object ) {
		$this->assertIndexIsBuild();

		$i = 0;
		foreach ( $this as $o ) {
			if ( $o === $object ) {
				return $i;
			}
			$i++;
		}
		return false;
	}

	/**
	 * Returns the objects in a flat array (using the indexed form for generating the array).
	 * @since 0.5
	 *
	 * @return PropertyIdProvider[]
	 * @throws RuntimeException
	 */
	public function toFlatArray() {
		$this->assertIndexIsBuild();

		$array = array();
		foreach ( $this->byId as $objects ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$array = array_merge( $array, $objects );
		}
		return $array;
	}

	/**
	 * Returns the absolute numeric indices of objects featuring the same property id.
	 *
	 * @param PropertyId $propertyId
	 *
	 * @throws RuntimeException
	 * @return int[]
	 */
	private function getFlatArrayIndices( PropertyId $propertyId ) {
		$this->assertIndexIsBuild();

		$propertyIndices = array();
		$i = 0;

		foreach ( $this->byId as $serializedPropertyId => $objects ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			if ( $serializedPropertyId === $propertyId->getSerialization() ) {
				$propertyIndices = range( $i, $i + count( $objects ) - 1 );
				break;
			} else {
				$i += count( $objects );
			}
		}

		return $propertyIndices;
	}

	/**
	 * Moves an object within its "property group".
	 *
	 * @param PropertyIdProvider $object
	 * @param int $toIndex Absolute index within a "property group".
	 *
	 * @throws OutOfBoundsException
	 */
	private function moveObjectInPropertyGroup( $object, $toIndex ) {
		$currentIndex = $this->getFlatArrayIndexOfObject( $object );

		if ( $toIndex === $currentIndex ) {
			return;
		}

		$propertyId = $object->getPropertyId();

		$numericIndices = $this->getFlatArrayIndices( $propertyId );
		$lastIndex = $numericIndices[count( $numericIndices ) - 1];

		if ( $toIndex > $lastIndex + 1 || $toIndex < $numericIndices[0] ) {
			throw new OutOfBoundsException( 'Object cannot be moved to ' . $toIndex );
		}

		if ( $toIndex >= $lastIndex ) {
			$this->moveObjectToEndOfPropertyGroup( $object );
		} else {
			$this->removeObject( $object );

			$propertyGroup = array_combine(
				$this->getFlatArrayIndices( $propertyId ),
				$this->getByPropertyId( $propertyId )
			);

			$insertBefore = $propertyGroup[$toIndex];
			$this->insertObjectAtIndex( $object, $this->getFlatArrayIndexOfObject( $insertBefore ) );

		}
	}

	/**
	 * Moves an object to the end of its "property group".
	 *
	 * @param PropertyIdProvider $object
	 */
	private function moveObjectToEndOfPropertyGroup( $object ) {
		$this->removeObject( $object );

		$propertyId = $object->getPropertyId();
		$propertyIdSerialization = $propertyId->getSerialization();

		$propertyGroup = in_array( $propertyIdSerialization, $this->getPropertyIds() )
			? $this->getByPropertyId( $propertyId )
			: array();

		$propertyGroup[] = $object;
		$this->byId[$propertyIdSerialization] = $propertyGroup;

		$this->exchangeArray( $this->toFlatArray() );
	}

	/**
	 * Removes an object from the array structures.
	 *
	 * @param PropertyIdProvider $object
	 */
	private function removeObject( $object ) {
		$flatArray = $this->toFlatArray();
		$this->exchangeArray( $flatArray );
		$this->offsetUnset( array_search( $object, $flatArray ) );
		$this->buildIndex();
	}

	/**
	 * Inserts an object at a specific index.
	 *
	 * @param PropertyIdProvider $object
	 * @param int $index Absolute index within the flat list of objects.
	 */
	private function insertObjectAtIndex( $object, $index ) {
		$flatArray = $this->toFlatArray();

		$this->exchangeArray( array_merge(
			array_slice( $flatArray, 0, $index ),
			array( $object ),
			array_slice( $flatArray, $index )
		) );

		$this->buildIndex();
	}

	/**
	 * @param PropertyId $propertyId
	 * @param int $toIndex
	 */
	private function movePropertyGroup( PropertyId $propertyId, $toIndex ) {
		if ( $this->getPropertyGroupIndex( $propertyId ) === $toIndex ) {
			return;
		}

		$insertBefore = null;

		$oldIndex = $this->getPropertyGroupIndex( $propertyId );
		$byIdClone = $this->byId;

		// Remove "property group" to calculate the groups new index:
		unset( $this->byId[$propertyId->getSerialization()] );

		if ( $toIndex > $oldIndex ) {
			// If the group shall be moved towards the bottom, the number of objects within the
			// group needs to be subtracted from the absolute toIndex:
			$toIndex -= count( $byIdClone[$propertyId->getSerialization()] );
		}

		foreach ( $this->getPropertyIds() as $pId ) {
			// Accepting other than the exact index by using <= letting the "property group" "latch"
			// in the next slot.
			if ( $toIndex <= $this->getPropertyGroupIndex( $pId ) ) {
				$insertBefore = $pId;
				break;
			}
		}

		$serializedPropertyId = $propertyId->getSerialization();
		$this->byId = array();

		foreach ( $byIdClone as $serializedPId => $objects ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$pId = new PropertyId( $serializedPId );
			if ( $pId->equals( $propertyId ) ) {
				continue;
			} elseif ( $pId->equals( $insertBefore ) ) {
				$this->byId[$serializedPropertyId] = $byIdClone[$serializedPropertyId];
			}
			$this->byId[$serializedPId] = $objects;
		}

		if ( $insertBefore === null ) {
			$this->byId[$serializedPropertyId] = $byIdClone[$serializedPropertyId];
		}

		$this->exchangeArray( $this->toFlatArray() );
	}

	/**
	 * Returns the index of a "property group" (the first object in the flat array that features
	 * the specified property). Returns false if property id could not be found.
	 *
	 * @param PropertyId $propertyId
	 *
	 * @return bool|int
	 */
	private function getPropertyGroupIndex( PropertyId $propertyId ) {
		$i = 0;

		foreach ( $this->byId as $serializedPropertyId => $objects ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$pId = new PropertyId( $serializedPropertyId );
			if ( $pId->equals( $propertyId ) ) {
				return $i;
			}
			$i += count( $objects );
		}

		return false;
	}

	/**
	 * Moves an existing object to a new index. Specifying an index outside the object's "property
	 * group" will move the object to the edge of the "property group" and shift the whole group
	 * to achieve the designated index for the object to move.
	 * @since 0.5
	 *
	 * @param PropertyIdProvider $object
	 * @param int $toIndex Absolute index where to move the object to.
	 *
	 * @throws OutOfBoundsException
	 * @throws RuntimeException
	 */
	public function moveObjectToIndex( $object, $toIndex ) {
		$this->assertIndexIsBuild();

		if ( !in_array( $object, $this->toFlatArray() ) ) {
			throw new OutOfBoundsException( 'Object not present in array' );
		} elseif ( $toIndex < 0 || $toIndex > count( $this ) ) {
			throw new OutOfBoundsException( 'Specified index is out of bounds' );
		} elseif ( $this->getFlatArrayIndexOfObject( $object ) === $toIndex ) {
			return;
		}

		// Determine whether to simply reindex the object within its "property group":
		$propertyIndices = $this->getFlatArrayIndices( $object->getPropertyId() );

		if ( in_array( $toIndex, $propertyIndices ) ) {
			$this->moveObjectInPropertyGroup( $object, $toIndex );
		} else {
			$edgeIndex = ( $toIndex <= $propertyIndices[0] )
				? $propertyIndices[0]
				: $propertyIndices[count( $propertyIndices ) - 1];

			$this->moveObjectInPropertyGroup( $object, $edgeIndex );
			$this->movePropertyGroup( $object->getPropertyId(), $toIndex );
		}

		$this->exchangeArray( $this->toFlatArray() );
	}

	/**
	 * Adds an object at a specific index. If no index is specified, the object will be append to
	 * the end of its "property group" or - if no objects featuring the same property exist - to the
	 * absolute end of the array.
	 * Specifying an index outside a "property group" will place the new object at the specified
	 * index with the existing "property group" objects being shifted towards the new object.
	 *
	 * @since 0.5
	 *
	 * @param PropertyIdProvider $object
	 * @param int|null $index Absolute index where to place the new object.
	 *
	 * @throws OutOfBoundsException
	 * @throws RuntimeException
	 */
	public function addObjectAtIndex( $object, $index = null ) {
		$this->assertIndexIsBuild();

		$propertyId = $object->getPropertyId();
		$validIndices = $this->getFlatArrayIndices( $propertyId );

		if ( count( $this ) === 0 ) {
			// Array is empty, just append object.
			$this->append( $object );
		} elseif ( empty( $validIndices ) ) {
			// No objects featuring that property exist. The object may be inserted at a place
			// between existing "property groups".
			$this->append( $object );
			if ( $index !== null ) {
				$this->buildIndex();
				$this->moveObjectToIndex( $object, $index );
			}
		} else {
			// Objects featuring the same property as the object which is about to be added already
			// exist in the array.
			$this->addObjectToPropertyGroup( $object, $index );
		}

		$this->buildIndex();
	}

	/**
	 * Adds an object to an existing property group at the specified absolute index.
	 *
	 * @param PropertyIdProvider $object
	 * @param int|null $index
	 *
	 * @throws OutOfBoundsException
	 */
	private function addObjectToPropertyGroup( $object, $index = null ) {
		$propertyId = $object->getPropertyId();
		$validIndices = $this->getFlatArrayIndices( $propertyId );

		if ( empty( $validIndices ) ) {
			throw new OutOfBoundsException( 'No objects featuring the object\'s property exist' );
		}

		// Add index to allow placing object after the last object of the "property group":
		$validIndices[] = $validIndices[count( $validIndices ) - 1] + 1;

		if ( $index === null ) {
			// If index is null, append object to "property group".
			$index = $validIndices[count( $validIndices ) - 1];
		}

		if ( in_array( $index, $validIndices ) ) {
			// Add object at index within "property group".
			$this->byId[$propertyId->getSerialization()][] = $object;
			$this->exchangeArray( $this->toFlatArray() );
			$this->moveObjectToIndex( $object, $index );

		} else {
			// Index is out of the "property group"; The whole group needs to be moved.
			$this->movePropertyGroup( $propertyId, $index );

			// Move new object to the edge of the "property group" to receive its designated
			// index:
			if ( $index < $validIndices[0] ) {
				array_unshift( $this->byId[$propertyId->getSerialization()], $object );
			} else {
				$this->byId[$propertyId->getSerialization()][] = $object;
			}
		}

		$this->exchangeArray( $this->toFlatArray() );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel;
4
5			use ArrayObject;
6			use InvalidArgumentException;
7			use OutOfBoundsException;
8			use RuntimeException;
9			use Traversable;
10			use Wikibase\DataModel\Entity\PropertyId;
11
12			/**
13			* Helper for managing objects indexed by property id.
14			*
15			* This is a light weight alternative approach to using something
16			* like GenericArrayObject with the advantages that no extra interface
17			* is needed and that indexing does not happen automatically.
18			*
19			* Lack of automatic indexing means that you will need to call the
20			* buildIndex method before doing any look-ups.
21			*
22			* Since no extra interface is used, the user is responsible for only
23			* adding objects that have a getPropertyId method that returns either
24			* a string or integer when called with no arguments.
25			*
26			* Objects may be added or moved within the structure. Absolute indices (indices according to the
27			* flat list of objects) may be specified to add or move objects. These management operations take
28			* the property grouping into account. Adding or moving objects outside their "property groups"
29			* shifts the whole group towards that index.
30			*
31			* Example of moving an object within its "property group":
32			* o1 (p1) o1 (p1)
33			* o2 (p2) /-> o3 (p2)
34			* o3 (p2) ---> move to index 1 -/ o2 (p2)
35			*
36			* Example of moving an object that triggers moving the whole "property group":
37			* o1 (p1) /-> o3 (p2)
38			* o2 (p2) \| o2 (p2)
39			* o3 (p2) ---> move to index 0 -/ o1 (p1)
40			*
41			* @since 0.2
42			* @deprecated since 5.0, use a DataModel Service instead
43			*
44			* @license GPL-2.0+
45			* @author H. Snater < [email protected] >
46			*/
47			class ByPropertyIdArray extends ArrayObject {
48
49			/**
50			* @var array[]\|null
51			*/
52			private $byId = null;
53
54			/**
55			* @deprecated since 5.0, use a DataModel Service instead
56			* @see ArrayObject::__construct
57			*
58			* @param PropertyIdProvider[]\|Traversable\|null $input
59			*
60			* @throws InvalidArgumentException
61			*/
62			public function __construct( $input = null ) {
63			if ( is_object( $input ) && !( $input instanceof Traversable ) ) {
64			throw new InvalidArgumentException( '$input must be an array, Traversable or null' );
65			}
66
67			parent::__construct( (array)$input );
68			}
69
70			/**
71			* Builds the index for doing look-ups by property id.
72			*
73			* @since 0.2
74			*/
75			public function buildIndex() {
76			$this->byId = array();
77
78			/** @var PropertyIdProvider $object */
79			foreach ( $this as $object ) {
80			$propertyId = $object->getPropertyId()->getSerialization();
81
82			if ( !array_key_exists( $propertyId, $this->byId ) ) {
83			$this->byId[$propertyId] = array();
84			}
85
86			$this->byId[$propertyId][] = $object;
87			}
88			}
89
90			/**
91			* Checks whether id indexed array has been generated.
92			*
93			* @throws RuntimeException
94			*/
95			private function assertIndexIsBuild() {
96			if ( $this->byId === null ) {
97			throw new RuntimeException( 'Index not build, call buildIndex first' );
98			}
99			}
100
101			/**
102			* Returns the property ids used for indexing.
103			*
104			* @since 0.2
105			*
106			* @return PropertyId[]
107			* @throws RuntimeException
108			*/
109			public function getPropertyIds() {
110			$this->assertIndexIsBuild();
111
112			return array_map(
113			function( $serializedPropertyId ) {
114			return new PropertyId( $serializedPropertyId );
115			},
116			array_keys( $this->byId )
117			);
118			}
119
120			/**
121			* Returns the objects featuring the provided property id in the index.
122			*
123			* @since 0.2
124			*
125			* @param PropertyId $propertyId
126			*
127			* @throws OutOfBoundsException
128			* @throws RuntimeException
129			* @return PropertyIdProvider[]
130			*/
131			public function getByPropertyId( PropertyId $propertyId ) {
132			$this->assertIndexIsBuild();
133
134			if ( !( array_key_exists( $propertyId->getSerialization(), $this->byId ) ) ) {
135			throw new OutOfBoundsException( "Object with propertyId \"$propertyId\" not found" );
136			}
137
138			return $this->byId[$propertyId->getSerialization()];
139			}
140
141			/**
142			* Returns the absolute index of an object or false if the object could not be found.
143			* @since 0.5
144			*
145			* @param PropertyIdProvider $object
146			*
147			* @return bool\|int
148			* @throws RuntimeException
149			*/
150			public function getFlatArrayIndexOfObject( $object ) {
151			$this->assertIndexIsBuild();
152
153			$i = 0;
154			foreach ( $this as $o ) {
155			if ( $o === $object ) {
156			return $i;
157			}
158			$i++;
159			}
160			return false;
161			}
162
163			/**
164			* Returns the objects in a flat array (using the indexed form for generating the array).
165			* @since 0.5
166			*
167			* @return PropertyIdProvider[]
168			* @throws RuntimeException
169			*/
170			public function toFlatArray() {
171			$this->assertIndexIsBuild();
172
173			$array = array();
174			foreach ( $this->byId as $objects ) {
			0 ignored issues – show Bug introduced 2015-11-27 17:36 UTC by Report Bug Copy Issue Report The expression `$this->byId` of type `array<integer,array>\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
175			$array = array_merge( $array, $objects );
176			}
177			return $array;
178			}
179
180			/**
181			* Returns the absolute numeric indices of objects featuring the same property id.
182			*
183			* @param PropertyId $propertyId
184			*
185			* @throws RuntimeException
186			* @return int[]
187			*/
188			private function getFlatArrayIndices( PropertyId $propertyId ) {
189			$this->assertIndexIsBuild();
190
191			$propertyIndices = array();
192			$i = 0;
193
194			foreach ( $this->byId as $serializedPropertyId => $objects ) {
			0 ignored issues – show Bug introduced 2015-12-14 10:23 UTC by Report Bug Copy Issue Report The expression `$this->byId` of type `array<integer,array>\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
195			if ( $serializedPropertyId === $propertyId->getSerialization() ) {
196			$propertyIndices = range( $i, $i + count( $objects ) - 1 );
197			break;
198			} else {
199			$i += count( $objects );
200			}
201			}
202
203			return $propertyIndices;
204			}
205
206			/**
207			* Moves an object within its "property group".
208			*
209			* @param PropertyIdProvider $object
210			* @param int $toIndex Absolute index within a "property group".
211			*
212			* @throws OutOfBoundsException
213			*/
214			private function moveObjectInPropertyGroup( $object, $toIndex ) {
215			$currentIndex = $this->getFlatArrayIndexOfObject( $object );
216
217			if ( $toIndex === $currentIndex ) {
218			return;
219			}
220
221			$propertyId = $object->getPropertyId();
222
223			$numericIndices = $this->getFlatArrayIndices( $propertyId );
224			$lastIndex = $numericIndices[count( $numericIndices ) - 1];
225
226			if ( $toIndex > $lastIndex + 1 \|\| $toIndex < $numericIndices[0] ) {
227			throw new OutOfBoundsException( 'Object cannot be moved to ' . $toIndex );
228			}
229
230			if ( $toIndex >= $lastIndex ) {
231			$this->moveObjectToEndOfPropertyGroup( $object );
232			} else {
233			$this->removeObject( $object );
234
235			$propertyGroup = array_combine(
236			$this->getFlatArrayIndices( $propertyId ),
237			$this->getByPropertyId( $propertyId )
238			);
239
240			$insertBefore = $propertyGroup[$toIndex];
241			$this->insertObjectAtIndex( $object, $this->getFlatArrayIndexOfObject( $insertBefore ) );
			0 ignored issues – show Security Bug introduced 2015-11-27 17:36 UTC by Report Bug Copy Issue Report It seems like `$this->getFlatArrayIndexOfObject($insertBefore)` targeting `Wikibase\DataModel\ByPro...latArrayIndexOfObject()` can also be of type `false`; however, `Wikibase\DataModel\ByPro...::insertObjectAtIndex()` does only seem to accept `integer`, did you maybe forget to handle an error condition? Loading history...
242			}
243			}
244
245			/**
246			* Moves an object to the end of its "property group".
247			*
248			* @param PropertyIdProvider $object
249			*/
250			private function moveObjectToEndOfPropertyGroup( $object ) {
251			$this->removeObject( $object );
252
253			$propertyId = $object->getPropertyId();
254			$propertyIdSerialization = $propertyId->getSerialization();
255
256			$propertyGroup = in_array( $propertyIdSerialization, $this->getPropertyIds() )
257			? $this->getByPropertyId( $propertyId )
258			: array();
259
260			$propertyGroup[] = $object;
261			$this->byId[$propertyIdSerialization] = $propertyGroup;
262
263			$this->exchangeArray( $this->toFlatArray() );
264			}
265
266			/**
267			* Removes an object from the array structures.
268			*
269			* @param PropertyIdProvider $object
270			*/
271			private function removeObject( $object ) {
272			$flatArray = $this->toFlatArray();
273			$this->exchangeArray( $flatArray );
274			$this->offsetUnset( array_search( $object, $flatArray ) );
275			$this->buildIndex();
276			}
277
278			/**
279			* Inserts an object at a specific index.
280			*
281			* @param PropertyIdProvider $object
282			* @param int $index Absolute index within the flat list of objects.
283			*/
284			private function insertObjectAtIndex( $object, $index ) {
285			$flatArray = $this->toFlatArray();
286
287			$this->exchangeArray( array_merge(
288			array_slice( $flatArray, 0, $index ),
289			array( $object ),
290			array_slice( $flatArray, $index )
291			) );
292
293			$this->buildIndex();
294			}
295
296			/**
297			* @param PropertyId $propertyId
298			* @param int $toIndex
299			*/
300			private function movePropertyGroup( PropertyId $propertyId, $toIndex ) {
301			if ( $this->getPropertyGroupIndex( $propertyId ) === $toIndex ) {
302			return;
303			}
304
305			$insertBefore = null;
306
307			$oldIndex = $this->getPropertyGroupIndex( $propertyId );
308			$byIdClone = $this->byId;
309
310			// Remove "property group" to calculate the groups new index:
311			unset( $this->byId[$propertyId->getSerialization()] );
312
313			if ( $toIndex > $oldIndex ) {
314			// If the group shall be moved towards the bottom, the number of objects within the
315			// group needs to be subtracted from the absolute toIndex:
316			$toIndex -= count( $byIdClone[$propertyId->getSerialization()] );
317			}
318
319			foreach ( $this->getPropertyIds() as $pId ) {
320			// Accepting other than the exact index by using <= letting the "property group" "latch"
321			// in the next slot.
322			if ( $toIndex <= $this->getPropertyGroupIndex( $pId ) ) {
323			$insertBefore = $pId;
324			break;
325			}
326			}
327
328			$serializedPropertyId = $propertyId->getSerialization();
329			$this->byId = array();
330
331			foreach ( $byIdClone as $serializedPId => $objects ) {
			0 ignored issues – show Bug introduced 2015-11-27 17:36 UTC by Report Bug Copy Issue Report The expression `$byIdClone` of type `array<integer,array>\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
332			$pId = new PropertyId( $serializedPId );
333			if ( $pId->equals( $propertyId ) ) {
334			continue;
335			} elseif ( $pId->equals( $insertBefore ) ) {
336			$this->byId[$serializedPropertyId] = $byIdClone[$serializedPropertyId];
337			}
338			$this->byId[$serializedPId] = $objects;
339			}
340
341			if ( $insertBefore === null ) {
342			$this->byId[$serializedPropertyId] = $byIdClone[$serializedPropertyId];
343			}
344
345			$this->exchangeArray( $this->toFlatArray() );
346			}
347
348			/**
349			* Returns the index of a "property group" (the first object in the flat array that features
350			* the specified property). Returns false if property id could not be found.
351			*
352			* @param PropertyId $propertyId
353			*
354			* @return bool\|int
355			*/
356			private function getPropertyGroupIndex( PropertyId $propertyId ) {
357			$i = 0;
358
359			foreach ( $this->byId as $serializedPropertyId => $objects ) {
			0 ignored issues – show Bug introduced 2015-12-14 10:23 UTC by Report Bug Copy Issue Report The expression `$this->byId` of type `array<integer,array>\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
360			$pId = new PropertyId( $serializedPropertyId );
361			if ( $pId->equals( $propertyId ) ) {
362			return $i;
363			}
364			$i += count( $objects );
365			}
366
367			return false;
368			}
369
370			/**
371			* Moves an existing object to a new index. Specifying an index outside the object's "property
372			* group" will move the object to the edge of the "property group" and shift the whole group
373			* to achieve the designated index for the object to move.
374			* @since 0.5
375			*
376			* @param PropertyIdProvider $object
377			* @param int $toIndex Absolute index where to move the object to.
378			*
379			* @throws OutOfBoundsException
380			* @throws RuntimeException
381			*/
382			public function moveObjectToIndex( $object, $toIndex ) {
383			$this->assertIndexIsBuild();
384
385			if ( !in_array( $object, $this->toFlatArray() ) ) {
386			throw new OutOfBoundsException( 'Object not present in array' );
387			} elseif ( $toIndex < 0 \|\| $toIndex > count( $this ) ) {
388			throw new OutOfBoundsException( 'Specified index is out of bounds' );
389			} elseif ( $this->getFlatArrayIndexOfObject( $object ) === $toIndex ) {
390			return;
391			}
392
393			// Determine whether to simply reindex the object within its "property group":
394			$propertyIndices = $this->getFlatArrayIndices( $object->getPropertyId() );
395
396			if ( in_array( $toIndex, $propertyIndices ) ) {
397			$this->moveObjectInPropertyGroup( $object, $toIndex );
398			} else {
399			$edgeIndex = ( $toIndex <= $propertyIndices[0] )
400			? $propertyIndices[0]
401			: $propertyIndices[count( $propertyIndices ) - 1];
402
403			$this->moveObjectInPropertyGroup( $object, $edgeIndex );
404			$this->movePropertyGroup( $object->getPropertyId(), $toIndex );
405			}
406
407			$this->exchangeArray( $this->toFlatArray() );
408			}
409
410			/**
411			* Adds an object at a specific index. If no index is specified, the object will be append to
412			* the end of its "property group" or - if no objects featuring the same property exist - to the
413			* absolute end of the array.
414			* Specifying an index outside a "property group" will place the new object at the specified
415			* index with the existing "property group" objects being shifted towards the new object.
416			*
417			* @since 0.5
418			*
419			* @param PropertyIdProvider $object
420			* @param int\|null $index Absolute index where to place the new object.
421			*
422			* @throws OutOfBoundsException
423			* @throws RuntimeException
424			*/
425			public function addObjectAtIndex( $object, $index = null ) {
426			$this->assertIndexIsBuild();
427
428			$propertyId = $object->getPropertyId();
429			$validIndices = $this->getFlatArrayIndices( $propertyId );
430
431			if ( count( $this ) === 0 ) {
432			// Array is empty, just append object.
433			$this->append( $object );
434			} elseif ( empty( $validIndices ) ) {
435			// No objects featuring that property exist. The object may be inserted at a place
436			// between existing "property groups".
437			$this->append( $object );
438			if ( $index !== null ) {
439			$this->buildIndex();
440			$this->moveObjectToIndex( $object, $index );
441			}
442			} else {
443			// Objects featuring the same property as the object which is about to be added already
444			// exist in the array.
445			$this->addObjectToPropertyGroup( $object, $index );
446			}
447
448			$this->buildIndex();
449			}
450
451			/**
452			* Adds an object to an existing property group at the specified absolute index.
453			*
454			* @param PropertyIdProvider $object
455			* @param int\|null $index
456			*
457			* @throws OutOfBoundsException
458			*/
459			private function addObjectToPropertyGroup( $object, $index = null ) {
460			$propertyId = $object->getPropertyId();
461			$validIndices = $this->getFlatArrayIndices( $propertyId );
462
463			if ( empty( $validIndices ) ) {
464			throw new OutOfBoundsException( 'No objects featuring the object\'s property exist' );
465			}
466
467			// Add index to allow placing object after the last object of the "property group":
468			$validIndices[] = $validIndices[count( $validIndices ) - 1] + 1;
469
470			if ( $index === null ) {
471			// If index is null, append object to "property group".
472			$index = $validIndices[count( $validIndices ) - 1];
473			}
474
475			if ( in_array( $index, $validIndices ) ) {
476			// Add object at index within "property group".
477			$this->byId[$propertyId->getSerialization()][] = $object;
478			$this->exchangeArray( $this->toFlatArray() );
479			$this->moveObjectToIndex( $object, $index );
480
481			} else {
482			// Index is out of the "property group"; The whole group needs to be moved.
483			$this->movePropertyGroup( $propertyId, $index );
484
485			// Move new object to the edge of the "property group" to receive its designated
486			// index:
487			if ( $index < $validIndices[0] ) {
488			array_unshift( $this->byId[$propertyId->getSerialization()], $object );
489			} else {
490			$this->byId[$propertyId->getSerialization()][] = $object;
491			}
492			}
493
494			$this->exchangeArray( $this->toFlatArray() );
495			}
496
497			}
498

wmde / WikibaseDataModel

Push — objectById ( 934c73 )

ByPropertyIdArray C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

17 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like