Queue::pop() - Code Metrics - Inspection of "Map fix, and stakc structure added" - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 1.x ( c7c61a...6ad606 )

by Ulises Jeremias

created 2017-12-14 13:04 UTC

Queue::pop() A

↳ Parent: Queue

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	3
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	3
loc	3
rs	10
c	0
b	0
f	0

<?php namespace Mbh\Collection;

/**
 * MBHFramework
 *
 * @link      https://github.com/MBHFramework/mbh-framework
 * @copyright Copyright (c) 2017 Ulises Jeremias Cornejo Fandos
 * @license   https://github.com/MBHFramework/mbh-framework/blob/master/LICENSE (MIT License)
 */

use Mbh\Collection\Interfaces\Collection as CollectionInterface;
use Traversable;
use ArrayAccess;
use IteratorAggregate;
use Error;
use OutOfBoundsException;

/**
 * A “first in, first out” or “FIFO” collection that only allows access to the
 * value at the front of the queue and iterates in that order, destructively.
 *
 * @package structures
 * @author Ulises Jeremias Cornejo Fandos <[email protected]>
 */

class Queue implements ArrayAccess, CollectionInterface, IteratorAggregate

{
    use Traits\Collection;

    const MIN_CAPACITY = 8;

    /**
     * @var Deque internal deque to store values.
     */
    private $deque;

    /**
     * Creates an instance using the values of an array or Traversable object.
     *
     * @param array|Traversable $values
     */
    public function __construct($values = [])
    {
        $this->deque = Deque::fromArray([]);

        $this->pushAll($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->deque->allocate($capacity);
    }

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

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

    /**
     * @inheritDoc
     */
    public function copy()
    {
        return new self($this->deque);
    }

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

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

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

    /**
     * Pushes zero or more values into the front of the queue.
     *
     * @param mixed ...$values
     */
    public function push(...$values)
    {
        $this->deque->push(...$values);
    }

    /**
     * Creates associations for all keys and corresponding values of either an
     * array or iterable object.
     *
     * @param Traversable|array $values
     */
    private function pushAll($values)
    {
        foreach ($values as &$value) {
            $this[] = $value;
        }
    }

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

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

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

    /**
     * @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();
    }
}


1		<?php namespace Mbh\Collection;
2
3		/**
4		* MBHFramework
5		*
6		* @link https://github.com/MBHFramework/mbh-framework
7		* @copyright Copyright (c) 2017 Ulises Jeremias Cornejo Fandos
8		* @license https://github.com/MBHFramework/mbh-framework/blob/master/LICENSE (MIT License)
9		*/
10
11		use Mbh\Collection\Interfaces\Collection as CollectionInterface;
12		use Traversable;
13		use ArrayAccess;
14		use IteratorAggregate;
15		use Error;
16		use OutOfBoundsException;
17
18		/**
19		* A “first in, first out” or “FIFO” collection that only allows access to the
20		* value at the front of the queue and iterates in that order, destructively.
21		*
22		* @package structures
23		* @author Ulises Jeremias Cornejo Fandos <[email protected]>
24		*/
25
26	View Code Duplication	class Queue implements ArrayAccess, CollectionInterface, IteratorAggregate
		0 ignored issues – show Duplication introduced 2017-12-14 13:07 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
27		{
28		use Traits\Collection;
29
30		const MIN_CAPACITY = 8;
31
32		/**
33		* @var Deque internal deque to store values.
34		*/
35		private $deque;
36
37		/**
38		* Creates an instance using the values of an array or Traversable object.
39		*
40		* @param array\|Traversable $values
41		*/
42		public function __construct($values = [])
43		{
44		$this->deque = Deque::fromArray([]);
45
46		$this->pushAll($values);
47		}
48
49		/**
50		* Ensures that enough memory is allocated for a specified capacity. This
51		* potentially reduces the number of reallocations as the size increases.
52		*
53		* @param int $capacity The number of values for which capacity should be
54		* allocated. Capacity will stay the same if this value
55		* is less than or equal to the current capacity.
56		*/
57		public function allocate(int $capacity)
58		{
59		$this->deque->allocate($capacity);
60		}
61
62		/**
63		* Returns the current capacity of the queue.
64		*
65		* @return int
66		*/
67		public function capacity(): int
68		{
69		return $this->deque->capacity();
70		}
71
72		/**
73		* @inheritDoc
74		*/
75		public function clear()
76		{
77		$this->deque->clear();
78		}
79
80		/**
81		* @inheritDoc
82		*/
83		public function copy()
84		{
85		return new self($this->deque);
86		}
87
88		/**
89		* @inheritDoc
90		*/
91		public function count(): int
92		{
93		return count($this->deque);
94		}
95
96		/**
97		* Returns the value at the front of the queue without removing it.
98		*
99		* @return
100		*/
101		public function peek()
102		{
103		return $this->deque->first();
104		}
105
106		/**
107		* Returns and removes the value at the front of the Queue.
108		*
109		* @return mixed
110		*/
111		public function pop()
112		{
113		return $this->deque->shift();
114		}
115
116		/**
117		* Pushes zero or more values into the front of the queue.
118		*
119		* @param mixed ...$values
120		*/
121		public function push(...$values)
122		{
123		$this->deque->push(...$values);
124		}
125
126		/**
127		* Creates associations for all keys and corresponding values of either an
128		* array or iterable object.
129		*
130		* @param Traversable\|array $values
131		*/
132		private function pushAll($values)
133		{
134		foreach ($values as &$value) {
135		$this[] = $value;
136		}
137		}
138
139		/**
140		* @inheritDoc
141		*/
142		public function toArray(): array
143		{
144		return $this->deque->toArray();
145		}
146
147		/**
148		* Get iterator
149		*/
150		public function getIterator()
151		{
152		while (!$this->isEmpty()) {
153		yield $this->pop();
154		}
155		}
156
157		/**
158		* @inheritdoc
159		*
160		* @throws OutOfBoundsException
161		*/
162		public function offsetSet($offset, $value)
163		{
164		if ($offset === null) {
165		$this->push($value);
166		} else {
167		throw new OutOfBoundsException();
168		}
169		}
170
171		/**
172		* @inheritdoc
173		*
174		* @throws Error
175		*/
176		public function offsetGet($offset)
177		{
178		throw new Error();
179		}
180
181		/**
182		* @inheritdoc
183		*
184		* @throws Error
185		*/
186		public function offsetUnset($offset)
187		{
188		throw new Error();
189		}
190
191		/**
192		* @inheritdoc
193		*
194		* @throws Error
195		*/
196		public function offsetExists($offset)
197		{
198		throw new Error();
199		}
200		}
201

MBHFramework / structures

Push — 1.x ( c7c61a...6ad606 )

Queue::pop() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like