Code Duplication - MBHFramework/structures - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 212-218 lines in 2 locations

Mbh/Collection/Queue.php 1 location


 * @author Ulises Jeremias Cornejo Fandos <[email protected]>
 */

class Queue implements ArrayAccess, CollectionInterface
{
    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();
    }

    /**
     * @inheritDoc
     */
    public function unserialize($values)
    {
        $values = unserialize($values);
        $this->deque = Deque::fromArray($values);
    }

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

    /**
     * Iterator
     */
    public function current()
    {
        return $this->deque->current();
    }

    public function key(): int
    {
        return $this->deque->key();
    }

    public function next()
    {
        return $this->deque->next();
    }

    public function rewind()
    {
        return $this->deque->rewind();
    }

    public function valid()
    {
        return $this->deque->valid();
    }
}


Mbh/Collection/Stack.php 1 location


 * @author Ulises Jeremias Cornejo Fandos <[email protected]>
 */

class Stack implements ArrayAccess, CollectionInterface
{
    use Traits\Collection;

    const MIN_CAPACITY = 8;

    /**
     * @var FixedArray internal sfa to store values of the stack.
     */
    private $sfa;

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

        $this->pushAll($values);
    }

    /**
     * Clear all elements in the Stack
     */
    public function clear()
    {
        $this->sfa->clear();
    }

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

    /**
     * Returns the number of elements in the Stack
     *
     * @return int
     */
    public function count(): int
    {
        return count($this->sfa);
    }

    /**
     * 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->sfa->allocate($capacity);
    }

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

    /**
     * Returns the value at the top of the stack without removing it.
     *
     * @return mixed
     *
     * @throws UnderflowException if the stack is empty.
     */
    public function peek()
    {
        return $this->sfa->last();
    }

    /**
     * Returns and removes the value at the top of the stack.
     *
     * @return mixed
     *
     * @throws UnderflowException if the stack is empty.
     */
    public function pop()
    {
        return $this->sfa->pop();
    }

    /**
     * Pushes zero or more values onto the top of the stack.
     *
     * @param mixed ...$values
     */
    public function push(...$values)
    {
        $this->sfa->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 array_reverse($this->sfa->toArray());
    }

    /**
     * @inheritDoc
     */
    public function unserialize($values)
    {
        $values = unserialize($values);
        $this->sfa = FixedArray::fromArray($values);
    }

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

    /**
     * Iterator
     */
    public function current()
    {
        return $this->sfa->current();
    }

    public function key(): int
    {
        return $this->sfa->key();
    }

    public function next()
    {
        return $this->sfa->next();
    }

    public function rewind()
    {
        return $this->sfa->rewind();
    }

    public function valid()
    {
        return $this->sfa->valid();
    }
}


		@@ 26-237 (lines=212) @@
23		* @author Ulises Jeremias Cornejo Fandos <[email protected]>
24		*/
25
26		class Queue implements ArrayAccess, CollectionInterface
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		* @inheritDoc
149		*/
150		public function unserialize($values)
151		{
152		$values = unserialize($values);
153		$this->deque = Deque::fromArray($values);
154		}
155
156		/**
157		* Get iterator
158		*/
159		public function getIterator()
160		{
161		while (!$this->isEmpty()) {
162		yield $this->pop();
163		}
164		}
165
166		/**
167		* @inheritdoc
168		*
169		* @throws OutOfBoundsException
170		*/
171		public function offsetSet($offset, $value)
172		{
173		if ($offset === null) {
174		$this->push($value);
175		} else {
176		throw new OutOfBoundsException();
177		}
178		}
179
180		/**
181		* @inheritdoc
182		*
183		* @throws Error
184		*/
185		public function offsetGet($offset)
186		{
187		throw new Error();
188		}
189
190		/**
191		* @inheritdoc
192		*
193		* @throws Error
194		*/
195		public function offsetUnset($offset)
196		{
197		throw new Error();
198		}
199
200		/**
201		* @inheritdoc
202		*
203		* @throws Error
204		*/
205		public function offsetExists($offset)
206		{
207		throw new Error();
208		}
209
210		/**
211		* Iterator
212		*/
213		public function current()
214		{
215		return $this->deque->current();
216		}
217
218		public function key(): int
219		{
220		return $this->deque->key();
221		}
222
223		public function next()
224		{
225		return $this->deque->next();
226		}
227
228		public function rewind()
229		{
230		return $this->deque->rewind();
231		}
232
233		public function valid()
234		{
235		return $this->deque->valid();
236		}
237		}
238

		@@ 27-244 (lines=218) @@
24		* @author Ulises Jeremias Cornejo Fandos <[email protected]>
25		*/
26
27		class Stack implements ArrayAccess, CollectionInterface
28		{
29		use Traits\Collection;
30
31		const MIN_CAPACITY = 8;
32
33		/**
34		* @var FixedArray internal sfa to store values of the stack.
35		*/
36		private $sfa;
37
38		/**
39		* Creates an instance using the values of an array or Traversable object.
40		*
41		* @param array\|\Traversable $values
42		*/
43		public function __construct($values = [])
44		{
45		$this->sfa = FixedArray::fromArray([]);
46
47		$this->pushAll($values);
48		}
49
50		/**
51		* Clear all elements in the Stack
52		*/
53		public function clear()
54		{
55		$this->sfa->clear();
56		}
57
58		/**
59		* @inheritdoc
60		*/
61		public function copy()
62		{
63		return new self($this->sfa);
64		}
65
66		/**
67		* Returns the number of elements in the Stack
68		*
69		* @return int
70		*/
71		public function count(): int
72		{
73		return count($this->sfa);
74		}
75
76		/**
77		* Ensures that enough memory is allocated for a specified capacity. This
78		* potentially reduces the number of reallocations as the size increases.
79		*
80		* @param int $capacity The number of values for which capacity should be
81		* allocated. Capacity will stay the same if this value
82		* is less than or equal to the current capacity.
83		*/
84		public function allocate(int $capacity)
85		{
86		$this->sfa->allocate($capacity);
87		}
88
89		/**
90		* Returns the current capacity of the stack.
91		*
92		* @return int
93		*/
94		public function capacity(): int
95		{
96		return $this->sfa->capacity();
97		}
98
99		/**
100		* Returns the value at the top of the stack without removing it.
101		*
102		* @return mixed
103		*
104		* @throws UnderflowException if the stack is empty.
105		*/
106		public function peek()
107		{
108		return $this->sfa->last();
109		}
110
111		/**
112		* Returns and removes the value at the top of the stack.
113		*
114		* @return mixed
115		*
116		* @throws UnderflowException if the stack is empty.
117		*/
118		public function pop()
119		{
120		return $this->sfa->pop();
121		}
122
123		/**
124		* Pushes zero or more values onto the top of the stack.
125		*
126		* @param mixed ...$values
127		*/
128		public function push(...$values)
129		{
130		$this->sfa->push(...$values);
131		}
132
133		/**
134		* Creates associations for all keys and corresponding values of either an
135		* array or iterable object.
136		*
137		* @param Traversable\|array $values
138		*/
139		private function pushAll($values)
140		{
141		foreach ($values as &$value) {
142		$this[] = $value;
143		}
144		}
145
146		/**
147		* @inheritDoc
148		*/
149		public function toArray(): array
150		{
151		return array_reverse($this->sfa->toArray());
152		}
153
154		/**
155		* @inheritDoc
156		*/
157		public function unserialize($values)
158		{
159		$values = unserialize($values);
160		$this->sfa = FixedArray::fromArray($values);
161		}
162
163		/**
164		*
165		*/
166		public function getIterator()
167		{
168		while (! $this->isEmpty()) {
169		yield $this->pop();
170		}
171		}
172
173		/**
174		* @inheritdoc
175		*
176		* @throws OutOfBoundsException
177		*/
178		public function offsetSet($offset, $value)
179		{
180		if ($offset === null) {
181		$this->push($value);
182		} else {
183		throw new OutOfBoundsException();
184		}
185		}
186
187		/**
188		* @inheritdoc
189		*
190		* @throws Error
191		*/
192		public function offsetGet($offset)
193		{
194		throw new Error();
195		}
196
197		/**
198		* @inheritdoc
199		*
200		* @throws Error
201		*/
202		public function offsetUnset($offset)
203		{
204		throw new Error();
205		}
206
207		/**
208		* @inheritdoc
209		*
210		* @throws Error
211		*/
212		public function offsetExists($offset)
213		{
214		throw new Error();
215		}
216
217		/**
218		* Iterator
219		*/
220		public function current()
221		{
222		return $this->sfa->current();
223		}
224
225		public function key(): int
226		{
227		return $this->sfa->key();
228		}
229
230		public function next()
231		{
232		return $this->sfa->next();
233		}
234
235		public function rewind()
236		{
237		return $this->sfa->rewind();
238		}
239
240		public function valid()
241		{
242		return $this->sfa->valid();
243		}
244		}
245

MBHFramework / structures

Code Duplication Length = 212-218 lines in 2 locations

Mbh/Collection/Queue.php 1 location

Mbh/Collection/Stack.php 1 location