Stack::add() - Code Metrics - Inspection of "More testing" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#335)

by thomas

created 2016-07-02 00:14 UTC

Stack::add() A

↳ Parent: Stack

Complexity

Conditions	4
Paths	5

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	4
eloc	11
c	2
b	0
f	0
nc	5
nop	2
dl	0
loc	19
ccs	0
cts	0
cp	0
crap	20
rs	9.2

<?php

namespace BitWasp\Bitcoin\Script\Interpreter;

use BitWasp\Buffertools\BufferInterface;

class Stack implements \Countable, \ArrayAccess, \Iterator
{
    /**
     * @var int
     */
    private $position = 0;

    /**
     * @var array
     */
    private $values = [];

    public function __construct()
    {

    }

    public function current()
    {
        return $this->values[$this->position];
    }

    public function next()
    {
        ++$this->position;
    }

    public function key()
    {
        return $this->position;
    }

    public function valid()
    {
        return isset($this->values[$this->position]);
    }

    public function rewind()
    {
        $this->position = 0;
    }

    public function count()
    {
        return count($this->values);
    }

    public function isEmpty()
    {
        return count($this->values) === 0;
    }

    public function bottom()
    {
        $count = count($this);
        if ($count < 1) {
            throw new \RuntimeException('No values in stack');
        }

        return $this->values[$count - 1];
    }

    /**
     * @see \ArrayAccess::offsetGet()
     * @param int $offset
     * @return \BitWasp\Buffertools\BufferInterface
     */
    public function offsetGet($offset)
    {
        $index = count($this) + $offset;
        if (!isset($this->values[$index])) {
            throw new \RuntimeException('No value at this position');
        }

        return $this->values[$index];
    }

    /**
     * @see \ArrayAccess::offsetSet()
     * @param int $offset
     * @param BufferInterface $value
     * @throws \InvalidArgumentException
     */
    public function offsetSet($offset, $value)
    {
        if (!$value instanceof BufferInterface) {
            throw new \InvalidArgumentException;
        }

        $count = count($this);
        $index = $count + $offset;
        if (isset($this->values[$index])) {
            $this->values[$index] = $value;
            return;
        }

        if ($index !== $count) {
            throw new \RuntimeException('Index must be end position');
        }
    }

    /**
     * @see \ArrayAccess::offsetExists()
     * @param int $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        $index = count($this) + $offset;
        return isset($this->values[$index]);
    }

    /**
     * @see \ArrayAccess::offsetUnset()
     * @param int $offset
     */
    public function offsetUnset($offset)
    {
        $count = count($this);
        $index = $count + $offset;
        if (!isset($this->values[$index])) {
            throw new \RuntimeException('Nothing at this position');
        }

        array_splice($this->values, $index, 1);
    }

    /**
     * @param int $first
     * @param int $second
     */
    public function swap($first, $second)
    {
        $val1 = $this->offsetGet($first);
        $val2 = $this->offsetGet($second);
        $this->offsetSet($second, $val1);
        $this->offsetSet($first, $val2);
    }

    /**
     * @param int $offset
     * @param BufferInterface $value
     */
    public function add($offset, $value)
    {
        $size = count($this);
        $index = $size + $offset;
        if ($index > $size) {
            throw new \RuntimeException('Invalid add position');
        }

        // Unwind current values, push provided value, reapply popped values
        $values = [];
        for ($i = $size; $i > $index; $i--) {
            $values[] = $this->pop();
        }

        $this->push($value);
        for ($i = count($values); $i > 0; $i--) {
            $this->push(array_pop($values));
        }
    }

    public function pop()
    {
        $count = count($this);
        if ($count === 0) {
            throw new \RuntimeException('Cannot pop from empty stack');
        }

        $value = array_pop($this->values);
        return $value;
    }

    public function push($buffer)
    {
        $this->values[] = $buffer;
    }

    /**
     * @return int
     */
    public function end()
    {
        $count = count($this);
        if ($count === 0) {
            return 0;
        }

        return $count - 1;
    }

    /**
     * @param int $length
     * @return $this
     */
    public function resize($length)
    {
        if ($length > count($this)) {
            throw new \RuntimeException('Invalid start or length');
        }

        while (count($this) > $length) {
            $this->pop();
        }

        return $this;
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Script\Interpreter;
4
5		use BitWasp\Buffertools\BufferInterface;
6
7		class Stack implements \Countable, \ArrayAccess, \Iterator
8		{
9	435	/**
10		* @var int
11	435	*/
12	435	private $position = 0;
13
14	24	/**
15		* @var array
16	24	*/
17		private $values = [];
18
19		public function __construct()
20		{
21
22		}
23	21
24		public function current()
25	21	{
26		return $this->values[$this->position];
27		}
28	21
29		public function next()
30		{
31		++$this->position;
32		}
33
34		public function key()
35	276	{
36		return $this->position;
37	276	}
38	276
39		public function valid()
40		{
41		return isset($this->values[$this->position]);
42		}
43
44		public function rewind()
45		{
46		$this->position = 0;
47	12	}
48
49	12	public function count()
50	12	{
51	12	return count($this->values);
52	12	}
53
54		public function isEmpty()
55		{
56		return count($this->values) === 0;
57		}
58
59	3	public function bottom()
60		{
61	3	$count = count($this);
62	3	if ($count < 1) {
63		throw new \RuntimeException('No values in stack');
64		}
65
66		return $this->values[$count - 1];
67		}
68
69	18	/**
70		* @see \ArrayAccess::offsetGet()
71	18	* @param int $offset
72	18	* @return \BitWasp\Buffertools\BufferInterface
73	15	*/
74		public function offsetGet($offset)
75		{
76		$index = count($this) + $offset;
77		if (!isset($this->values[$index])) {
78		throw new \RuntimeException('No value at this position');
79	12	}
80
81	12	return $this->values[$index];
82	12	}
83	12
84	12	/**
85	12	* @see \ArrayAccess::offsetSet()
86		* @param int $offset
87		* @param BufferInterface $value
88		* @throws \InvalidArgumentException
89		*/
90		public function offsetSet($offset, $value)
91	9	{
92		if (!$value instanceof BufferInterface) {
93	9	throw new \InvalidArgumentException;
94		}
95	9
96		$count = count($this);
97		$index = $count + $offset;
98		if (isset($this->values[$index])) {
99		$this->values[$index] = $value;
100		return;
101		}
102
103		if ($index !== $count) {
104		throw new \RuntimeException('Index must be end position');
105		}
106		}
107
108		/**
109		* @see \ArrayAccess::offsetExists()
110		* @param int $offset
111	9	* @return bool
112		*/
113	6	public function offsetExists($offset)
114		{
115		$index = count($this) + $offset;
116		return isset($this->values[$index]);
117		}
118	405
119		/**
120	405	* @see \ArrayAccess::offsetUnset()
121	405	* @param int $offset
122	405	*/
123		public function offsetUnset($offset)
124		{
125		$count = count($this);
126		$index = $count + $offset;
127		if (!isset($this->values[$index])) {
128		throw new \RuntimeException('Nothing at this position');
129		}
130
131		array_splice($this->values, $index, 1);
132	15	}
133
134	15	/**
135		* @param int $first
136		* @param int $second
137		*/
138	15	public function swap($first, $second)
139	15	{
140	10	$val1 = $this->offsetGet($first);
141		$val2 = $this->offsetGet($second);
142	15	$this->offsetSet($second, $val1);
143		$this->offsetSet($first, $val2);
144		}
145
146		/**
147		* @param int $offset
148		* @param BufferInterface $value
149		*/
150		public function add($offset, $value)
151		{
152		$size = count($this);
153		$index = $size + $offset;
154		if ($index > $size) {
155		throw new \RuntimeException('Invalid add position');
156		}
157
158		// Unwind current values, push provided value, reapply popped values
159		$values = [];
160		for ($i = $size; $i > $index; $i--) {
161		$values[] = $this->pop();
162		}
163
164		$this->push($value);
165		for ($i = count($values); $i > 0; $i--) {
166		$this->push(array_pop($values));
167		}
168		}
169
170		public function pop()
171		{
172		$count = count($this);
173		if ($count === 0) {
174		throw new \RuntimeException('Cannot pop from empty stack');
175		}
176
177		$value = array_pop($this->values);
178		return $value;
179		}
180
181		public function push($buffer)
182		{
183		$this->values[] = $buffer;
184		}
185
186		/**
187		* @return int
188		*/
189		public function end()
190		{
191		$count = count($this);
192		if ($count === 0) {
193		return 0;
194		}
195
196		return $count - 1;
197		}
198
199		/**
200		* @param int $length
201		* @return $this
202		*/
203		public function resize($length)
204		{
205		if ($length > count($this)) {
206		throw new \RuntimeException('Invalid start or length');
207		}
208
209		while (count($this) > $length) {
210		$this->pop();
211		}
212
213		return $this;
214		}
215		}
216

Bit-Wasp / bitcoin-php

Pull Request — master (#335)

Stack::add() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like