Wikibase\DataModel\Snak\SnakList

Complexity

Total Complexity

53

Size/Duplication

Total Lines	402
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	13	5
A	getNewOffset()	0	7	2
B	preSetElement()	0	22	4
B	offsetUnset()	0	26	5
A	getHash()	0	4	1
A	equals()	0	8	3
A	removeDuplicates()	0	17	3
A	append()	0	3	1
A	offsetSet()	0	3	1
B	setElement()	0	15	5
A	serialize()	0	6	1
A	unserialize()	0	11	2
A	isEmpty()	0	3	1
A	hasSnakHash()	0	3	1
A	removeSnakHash()	0	11	3
A	addSnak()	0	8	2
A	hasSnak()	0	3	1
A	removeSnak()	0	3	1
A	getSnak()	0	13	3
A	orderByProperty()	0	11	3
A	moveSnaksToBottom()	0	6	2
A	getSnaksByProperty()	0	14	3

<?php

namespace Wikibase\DataModel\Snak;

use ArrayObject;
use Comparable;
use Hashable;
use InvalidArgumentException;
use Traversable;
use Wikibase\DataModel\Internal\MapValueHasher;

/**
 * List of Snak objects.
 * Indexes the snaks by hash and ensures no more the one snak with the same hash are in the list.
 *
 * @since 0.1
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 * @author Addshore
 */
class SnakList extends ArrayObject implements Hashable, Comparable {

	/**
	 * Maps snak hashes to their offsets.
	 *
	 * @var array [ snak hash (string) => array [ snak offset (string|int) ] | snak offset (string|int) ]
	 */
	private $offsetHashes = [];

	/**
	 * @var integer
	 */
	private $indexOffset = 0;

	/**
	 * @see ArrayObject::__construct
	 *
	 * @param array|Traversable|null $input
	 * @param int $flags
	 * @param string $iteratorClass
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $input = null, $flags = 0, $iteratorClass = 'ArrayIterator' ) {
		parent::__construct( [], $flags, $iteratorClass );

		if ( $input !== null ) {
			if ( !is_array( $input ) && !( $input instanceof Traversable ) ) {
				throw new InvalidArgumentException( '$input must be an array or Traversable' );
			}

			foreach ( $input as $offset => $value ) {
				$this->offsetSet( $offset, $value );
			}
		}
	}

	/**
	 * Finds a new offset for when appending an element.
	 * The base class does this, so it would be better to integrate,
	 * but there does not appear to be any way to do this...
	 *
	 * @return integer
	 */
	private function getNewOffset() {
		while ( $this->offsetExists( $this->indexOffset ) ) {
			$this->indexOffset++;
		}

		return $this->indexOffset;
	}

	/**
	 * Gets called before a new element is added to the list.
	 *
	 * Should return a boolean. When false is returned the element
	 * does not get added to the ArrayObject.
	 *
	 * @since 0.1
	 *
	 * @param int|string $index
	 * @param Hashable $hashable
	 *
	 * @return bool
	 */
	private function preSetElement( $index, $hashable ) {
		$hash = $hashable->getHash();

		$hasHash = $this->hasSnakHash( $hash );

		if ( $hasHash ) {
			return false;
		}

		if ( $hasHash ) {
			if ( !is_array( $this->offsetHashes[$hash] ) ) {
				$this->offsetHashes[$hash] = [ $this->offsetHashes[$hash] ];
			}

			$this->offsetHashes[$hash][] = $index;
		}
		else {
			$this->offsetHashes[$hash] = $index;
		}

		return true;
	}

	/**
	 * @see ArrayObject::offsetUnset
	 *
	 * @since 0.1
	 *
	 * @param mixed $index
	 */
	public function offsetUnset( $index ) {
		if ( $this->offsetExists( $index ) ) {
			/**
			 * @var Hashable $element
			 */
			$element = $this->offsetGet( $index );

			$hash = $element->getHash();

			if ( array_key_exists( $hash, $this->offsetHashes )
				&& is_array( $this->offsetHashes[$hash] )
				&& count( $this->offsetHashes[$hash] ) > 1 ) {
				$this->offsetHashes[$hash] = array_filter(
					$this->offsetHashes[$hash],
					function( $value ) use ( $index ) {
						return $value !== $index;
					}
				);
			}
			else {
				unset( $this->offsetHashes[$hash] );
			}

			parent::offsetUnset( $index );
		}
	}

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

	/**
	 * @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->getHash() === $target->getHash();
	}

	/**
	 * Removes duplicates bases on hash value.
	 *
	 * @since 0.3
	 */
	public function removeDuplicates() {
		$knownHashes = [];

		/**
		 * @var Hashable $hashable
		 */
		foreach ( iterator_to_array( $this ) as $hashable ) {
			$hash = $hashable->getHash();

			if ( in_array( $hash, $knownHashes ) ) {
				$this->removeSnakHash( $hash );
			}
			else {
				$knownHashes[] = $hash;
			}
		}
	}

	/**
	 * @see ArrayObject::append
	 *
	 * @param mixed $value
	 */
	public function append( $value ) {
		$this->setElement( null, $value );
	}

	/**
	 * @see ArrayObject::offsetSet()
	 *
	 * @param mixed $index
	 * @param mixed $value
	 */
	public function offsetSet( $index, $value ) {
		$this->setElement( $index, $value );
	}

	/**
	 * Method that actually sets the element and holds
	 * all common code needed for set operations, including
	 * type checking and offset resolving.
	 *
	 * If you want to do additional indexing or have code that
	 * otherwise needs to be executed whenever an element is added,
	 * you can overload @see preSetElement.
	 *
	 * @param mixed $index
	 * @param mixed $value
	 *
	 * @throws InvalidArgumentException
	 */
	private function setElement( $index, $value ) {
		if ( ! $value instanceof Snak ) {
			$type = is_object( $value ) ? get_class( $value ) : gettype( $value );

			throw new InvalidArgumentException( '$value must be an instance of Snak; got ' . $type );
		}

		if ( $index === null ) {
			$index = $this->getNewOffset();
		}

		if ( $this->preSetElement( $index, $value ) ) {
			parent::offsetSet( $index, $value );

It seems like you call parent on a different method (offsetSet() instead of setElement()). Are you sure this is correct? If so, you might want to change this to $this->offsetSet().

		}
	}

	/**
	 * @see Serializable::serialize
	 *
	 * @return string
	 */
	public function serialize() {
		return serialize( [
			'data' => $this->getArrayCopy(),
			'index' => $this->indexOffset,
		] );
	}

	/**
	 * @see Serializable::unserialize
	 *
	 * @param string $serialized
	 */
	public function unserialize( $serialized ) {
		$serializationData = unserialize( $serialized );

		foreach ( $serializationData['data'] as $offset => $value ) {
			// Just set the element, bypassing checks and offset resolving,
			// as these elements have already gone through this.
			parent::offsetSet( $offset, $value );

It seems like you call parent on a different method (offsetSet() instead of unserialize()). Are you sure this is correct? If so, you might want to change this to $this->offsetSet().

		}

		$this->indexOffset = $serializationData['index'];
	}

	/**
	 * Returns if the ArrayObject has no elements.
	 *
	 * @return bool
	 */
	public function isEmpty() {
		return !$this->getIterator()->valid();
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 *
	 * @return boolean
	 */
	public function hasSnakHash( $snakHash ) {
		return array_key_exists( $snakHash, $this->offsetHashes );
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 */
	public function removeSnakHash( $snakHash ) {
		if ( $this->hasSnakHash( $snakHash ) ) {
			$offset = $this->offsetHashes[$snakHash];

			if ( is_array( $offset ) ) {
				$offset = reset( $offset );
			}

			$this->offsetUnset( $offset );
		}
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 *
	 * @return boolean Indicates if the snak was added or not.
	 */
	public function addSnak( Snak $snak ) {
		if ( $this->hasSnak( $snak ) ) {
			return false;
		}

		$this->append( $snak );
		return true;
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 *
	 * @return boolean
	 */
	public function hasSnak( Snak $snak ) {
		return $this->hasSnakHash( $snak->getHash() );
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 */
	public function removeSnak( Snak $snak ) {
		$this->removeSnakHash( $snak->getHash() );
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 *
	 * @return Snak|bool
	 */
	public function getSnak( $snakHash ) {
		if ( !$this->hasSnakHash( $snakHash ) ) {
			return false;
		}

		$offset = $this->offsetHashes[$snakHash];

		if ( is_array( $offset ) ) {
			$offset = reset( $offset );
		}

		return $this->offsetGet( $offset );
	}

	/**
	 * Orders the snaks in the list grouping them by property.
	 *
	 * @param string[] $order List of serliazed property ids to order by.
	 *
	 * @since 0.5
	 */
	public function orderByProperty( array $order = [] ) {
		$snaksByProperty = $this->getSnaksByProperty();
		$orderedProperties = array_unique( array_merge( $order, array_keys( $snaksByProperty ) ) );

		foreach ( $orderedProperties as $property ) {
			if ( array_key_exists( $property, $snaksByProperty ) ) {
				$snaks = $snaksByProperty[$property];
				$this->moveSnaksToBottom( $snaks );
			}
		}
	}

	/**
	 * @param Snak[] $snaks to remove and re add
	 */
	private function moveSnaksToBottom( array $snaks ) {
		foreach ( $snaks as $snak ) {
			$this->removeSnak( $snak );
			$this->addSnak( $snak );
		}
	}

	/**
	 * Gets the snaks in the current object in an array
	 * grouped by property id
	 *
	 * @return array[]
	 */
	private function getSnaksByProperty() {
		$snaksByProperty = [];

		foreach ( $this as $snak ) {
			/** @var Snak $snak */
			$propertyId = $snak->getPropertyId()->getSerialization();
			if ( !isset( $snaksByProperty[$propertyId] ) ) {
				$snaksByProperty[$propertyId] = [];
			}
			$snaksByProperty[$propertyId][] = $snak;
		}

		return $snaksByProperty;
	}

}