Nexendrie\Utils\TCollection

Complexity

Total Complexity

44

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	toArray()	0	2	1
A	isLocked()	0	2	1
A	addChecker()	0	2	1
A	offsetExists()	0	2	2
A	getIterator()	0	2	1
A	count()	0	2	1
A	lock()	0	2	1
A	__construct()	0	5	1
A	offsetGet()	0	5	3
A	checkType()	0	3	2
A	checkSize()	0	6	3
A	hasItems()	0	2	1
A	checkUniqueness()	0	7	3
A	checkLock()	0	3	2
A	performChecks()	0	3	2
A	offsetSet()	0	8	4
A	offsetUnset()	0	7	4
A	getItem()	0	6	2
A	getItems()	0	2	1
A	removeByFilter()	0	4	3
A	fromArray()	0	6	2
A	getIndex()	0	7	3

<?php
declare(strict_types=1);

namespace Nexendrie\Utils;

/**
 * TCollection
 * Target class has to implement \ArrayAccess, \Countable, \IteratorAggregate interfaces
 *
 * @author Jakub Konečný
 */
trait TCollection {
  /** @var object[] */
  protected $items = [];
  /** @var string Type of items in the collection */
  protected $class;
  /** @var string|NULL */
  protected $uniqueProperty = null;
  /** @var int */
  protected $maxSize = 0;
  /** @var bool */
  protected $locked = false;
  /** @var callable[] */
  protected $checkers = [];
  
  public function __construct() {
    $this->addChecker([$this, "checkLock"]);
    $this->addChecker([$this, "checkType"]);
    $this->addChecker([$this, "checkUniqueness"]);
    $this->addChecker([$this, "checkSize"]);
  }
  
  public function isLocked(): bool {
    return $this->locked;
  }
  
  public function lock(): void {
    $this->locked = true;
  }
  
  public function count(): int {
    return count($this->items);
  }
  
  public function getIterator(): \ArrayIterator {
    return new \ArrayIterator($this->items);
  }
  
  /**
   * @param int $index
   */
  public function offsetExists($index): bool {
    return $index >= 0 AND $index < count($this->items);
  }
  
  /**
   * @param int|NULL $index
   * @return object
   * @throws \OutOfRangeException
   */
  public function offsetGet($index) {
    if($index < 0 OR $index >= count($this->items)) {
      throw new \OutOfRangeException("Offset invalid or out of range.");
    }
    return $this->items[$index];
  }
  
  public function addChecker(callable $checker): void {
    $this->checkers[] = $checker;
  }

  protected function checkLock(object $newItem, self $collection): void {

The method parameter $newItem is never used

    if($collection->locked) {
      throw new \RuntimeException("Cannot add items to locked collection.");
    }
  }

  protected function checkType(object $newItem, self $collection): void {
    if(!$newItem instanceof $collection->class) {
      throw new \InvalidArgumentException("Argument must be of $this->class type.");
    }
  }

  protected function checkUniqueness(object $newItem, self $collection): void {
    $uniqueProperty = $collection->uniqueProperty;
    if(is_null($uniqueProperty)) {
      return;
    }
    if($this->hasItems([$uniqueProperty => $newItem->$uniqueProperty])) {
      throw new \RuntimeException("Duplicate $uniqueProperty {$newItem->$uniqueProperty}.");
    }
  }

  protected function checkSize(object $newItem, self $collection): void {

The method parameter $newItem is never used

    if($collection->maxSize < 1) {
      return;
    }
    if($collection->count() + 1 > $collection->maxSize) {
      throw new \RuntimeException("Collection reached its max size. Cannot add more items.");
    }
  }

  protected function performChecks(object $item): void {
    foreach($this->checkers as $checker) {
      call_user_func($checker, $item, $this);
    }
  }
  
  /**
   * @param int|NULL $index
   * @param object $item
   * @throws \OutOfRangeException
   * @throws \InvalidArgumentException
   * @throws \RuntimeException
   */
  public function offsetSet($index, $item): void {
    $this->performChecks($item);
    if($index === null) {
      $this->items[] = & $item;
    } elseif($index < 0 OR $index >= count($this->items)) {
      throw new \OutOfRangeException("Offset invalid or out of range.");
    } else {
      $this->items[$index] = & $item;
    }
  }
  
  /**
   * @param int $index
   * @throws \RuntimeException
   * @throws \OutOfRangeException
   */
  public function offsetUnset($index): void {
    if($this->locked) {
      throw new \RuntimeException("Cannot remove items from locked collection.");
    } elseif($index < 0 OR $index >= count($this->items)) {
      throw new \OutOfRangeException("Offset invalid or out of range.");
    }
    array_splice($this->items, $index, 1);
  }
  
  public function toArray(): array {
    return $this->items;
  }
  
  /**
   * Create new collection from array
   */
  public static function fromArray(array $items, ...$args): self {
    $collection = new static(...$args);

The call to Nexendrie\Utils\TCollection::__construct() has too many arguments starting with $args.

    foreach($items as $item) {
      $collection[] = $item;
    }
    return $collection;
  }
  
  /**
   * Check if the collection has at least 1 item matching the filter
   */
  public function hasItems(array $filter = []): bool {
    return (count($this->getItems($filter)) > 0);
  }
  
  /**
   * Get all items matching the filter
   */
  public function getItems(array $filter = []): array {
    return Filter::applyFilter($this->items, $filter);
  }

  /**
   * Get first item matching the filter
   */
  public function getItem(array $filter): ?object {
    $items = $this->getItems($filter);
    if(count($items) === 0) {
      return null;
    }
    return $items[0];
  }

  /**
   * Remove all items matching the filter
   *
   * @throws \RuntimeException
   * @throws \OutOfRangeException
   */
  public function removeByFilter(array $filter): void {
    foreach($this->items as $index => $item) {
      if(Filter::matches($item, $filter)) {
        $this->offsetUnset($index);
      }
    }
  }

  /**
   * Get index of first item matching the filter
   */
  public function getIndex(array $filter): ?int {
    foreach($this->items as $index => $item) {
      if(Filter::matches($item, $filter)) {
        return $index;
      }
    }
    return null;
  }
}
?>