Collections\Traits\GuardTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Test Coverage

Coverage

62.5%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
	isEmpty()	0	1	?
	count()	0	1	?
A	emptyGuard()	0	6	2
A	validateKeyBounds()	0	6	2
A	validateKeyDoesNotExists()	0	6	2
A	validateKeyExists()	0	6	2
A	isBoundedKey()	0	4	2
A	validateKeyType()	0	6	2
A	validateTraversable()	0	6	3

<?php

namespace Collections\Traits;

use Collections\Exception\EmptyException;
use Collections\Exception\InvalidArgumentException;
use Collections\Exception\KeyException;
use Collections\Exception\TypeException;

trait GuardTrait
{
    abstract function isEmpty();

It is generally recommended to explicitly declare the visibility for methods.

    abstract function count();

It is generally recommended to explicitly declare the visibility for methods.

    /**
     * Ensures that we throw the correct exception when an empty collection is found
     * @param $method
     * @throws EmptyException
     */
    protected function emptyGuard($method)
    {
        if ($this->isEmpty()) {
            throw new EmptyException("{$method} cannot be called when the structure is empty");
        }
    }

    /**
     * Validates if a key is withing bounds (usually only useful with vectors)
     * @param $key
     */
    protected function validateKeyBounds($key)
    {
        if (!$this->isBoundedKey($key)) {
            throw new \OutOfBoundsException("Integer key $key is out of bounds");
        }
    }

    /**
     * @param $key
     */
    protected function validateKeyDoesNotExists($key)
    {
        if (!$this->containsKey($key)) {

It seems like containsKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            throw new \OutOfBoundsException('No element at position ' . $key);
        }
    }

    /**
     * @param $key
     */
    protected function validateKeyExists($key)
    {
        if ($this->containsKey($key)) {

It seems like containsKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            throw new KeyException('The key ' . $key . ' already exists!');
        }
    }

    /**
     * @param int $element
     * @return bool
     */
    protected function isBoundedKey($element)
    {
        return $element >= 0 && $element < $this->count();
    }

    /**
     * Validate if an element respects the correct type (usually only useful with vectors)
     * @param $element
     * @throws TypeException
     */
    protected function validateKeyType($element)
    {
        if (filter_var($element, FILTER_VALIDATE_INT) === false) {
            throw new TypeException('Only integer keys may be used with ' . (get_class($this)));
        }
    }

    protected function validateTraversable($traversable)
    {
        if (!is_array($traversable) && !$traversable instanceof \Traversable) {
            throw InvalidArgumentException::invalidTraversable();
        }
    }
}