Ds\Queue

Complexity

Total Complexity

18

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	allocate()	0	4	1
A	capacity()	0	4	1
A	clear()	0	4	1
A	copy()	0	4	1
A	count()	0	4	1
A	peek()	0	4	1
A	pop()	0	4	1
A	push()	0	4	1
A	__construct()	0	4	2
A	toArray()	0	4	1
A	getIterator()	0	6	2
A	offsetSet()	0	8	2
A	offsetGet()	0	4	1
A	offsetUnset()	0	4	1
A	offsetExists()	0	4	1

<?php
namespace Ds;

use \Error;

/**
 * Queue
 * @package Ds
 */
final class Queue implements \IteratorAggregate, \ArrayAccess, Collection
{
    use Traits\Collection;

    const MIN_CAPACITY = 8;

    /**
     * @var Deque
     */
    private $internal;

    /**
     * Creates an instance using the values of an array or Traversable object.
     *
     * @param array|\Traversable $values

Should the type for parameter $values not be array|\Traversable|null? Also, consider making the array more specific, something like array<String>, or String[].

     */
    public function __construct($values = null)
    {
        $this->internal = new Deque($values ?: []);
    }

    /**
     * Ensures that enough memory is allocated for a specified capacity. This
     * potentially reduces the number of reallocations as the size increases.
     *
     * @param int $capacity The number of values for which capacity should be
     *                      allocated. Capacity will stay the same if this value
     *                      is less than or equal to the current capacity.
     */
    public function allocate(int $capacity)
    {
        $this->internal->allocate($capacity);
    }

    /**
     * Returns the current capacity of the queue.
     *
     * @return int
     */
    public function capacity(): int
    {
        return $this->internal->capacity();
    }

    /**
     * @inheritDoc
     */
    public function clear()
    {
        $this->internal->clear();
    }

    /**
     * @inheritDoc
     */
    public function copy(): \Ds\Collection
    {
        return new self($this->internal);
    }

    /**
     * @inheritDoc
     */
    public function count(): int
    {
        return count($this->internal);
    }

    /**
     * Returns the value at the front of the queue without removing it.
     *
     * @return
     */
    public function peek()
    {
        return $this->internal->first();
    }

    /**
     * Returns and removes the value at the front of the Queue.
     *
     * @return mixed
     */
    public function pop()
    {
        return $this->internal->shift();
    }

    /**
     * Pushes zero or more values into the front of the queue.
     *
     * @param mixed ...$values
     */

Consider making the type for parameter $values a bit more specific; maybe use array.

    public function push(...$values)
    {
        $this->internal->push(...$values);
    }

    /**
     * @inheritDoc
     */
    public function toArray(): array
    {
        return $this->internal->toArray();
    }

    /**
     * Get iterator
     */
    public function getIterator()
    {
        while ( ! $this->isEmpty()) {
            yield $this->pop();
        }
    }


    /**
     * @inheritdoc
     *
     * @throws Error
     */
    public function offsetSet($offset, $value)
    {
        if ($offset === null) {
            $this->push($value);
        } else {
            throw new Error();
        }
    }

    /**
     * @inheritdoc
     *
     * @throws Error
     */
    public function offsetGet($offset)
    {
        throw new Error();
    }

    /**
     * @inheritdoc
     *
     * @throws Error
     */
    public function offsetUnset($offset)
    {
        throw new Error();
    }

    /**
     * @inheritdoc
     *
     * @throws Error
     */
    public function offsetExists($offset)
    {
        throw new Error();
    }
}