Stack::key() - Code Metrics - Inspection of "use new scrutinizer" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( eabe8c...61f277 )

by thomas

created 2018-12-01 18:10 UTC

Stack::key() A

↳ Parent: Stack

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Script\Interpreter;

use BitWasp\Buffertools\BufferInterface;

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

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

    /**
     * Stack constructor.
     * @param BufferInterface[] $values
     */
    public function __construct(array $values = [])
    {
        $this->values = array_map(function (BufferInterface $value) {
            return $value;
        }, $values);
    }

    /**
     * @return BufferInterface[]
     */
    public function all()
    {
        return $this->values;
    }

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

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

    /**
     * @return int
     */
    public function key()
    {
        return $this->position;
    }

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

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

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

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

    /**
     * @return BufferInterface
     */
    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		declare(strict_types=1);
4
5		namespace BitWasp\Bitcoin\Script\Interpreter;
6
7		use BitWasp\Buffertools\BufferInterface;
8
9		class Stack implements \Countable, \ArrayAccess, \Iterator
10		{
11		/**
12		* @var int
13		*/
14		private $position = 0;
15
16		/**
17		* @var BufferInterface[]
18		*/
19		private $values = [];
20
21		/**
22		* Stack constructor.
23		* @param BufferInterface[] $values
24		*/
25		public function __construct(array $values = [])
26		{
27	4814	$this->values = array_map(function (BufferInterface $value) {
28	98	return $value;
29	4814	}, $values);
30	4814	}
31
32		/**
33		* @return BufferInterface[]
34		*/
35	95	public function all()
36		{
37	95	return $this->values;
38		}
39
40		/**
41		* @return BufferInterface
42		*/
43	2858	public function current()
44		{
45	2858	return $this->values[$this->position];
46		}
47
48	2858	public function next()
49		{
50	2858	++$this->position;
51	2858	}
52
53		/**
54		* @return int
55		*/
56		public function key()
57		{
58		return $this->position;
59		}
60
61		/**
62		* @return bool
63		*/
64	4790	public function valid()
65		{
66	4790	return isset($this->values[$this->position]);
67		}
68
69	4790	public function rewind()
70		{
71	4790	$this->position = 0;
72	4790	}
73
74		/**
75		* @return int
76		*/
77	4692	public function count()
78		{
79	4692	return count($this->values);
80		}
81
82		/**
83		* @return bool
84		*/
85	3866	public function isEmpty()
86		{
87	3866	return count($this->values) === 0;
88		}
89
90		/**
91		* @return BufferInterface
92		*/
93	289	public function bottom()
94		{
95	289	$count = count($this);
96	289	if ($count < 1) {
97		throw new \RuntimeException('No values in stack');
98		}
99
100	289	return $this->values[$count - 1];
101		}
102
103		/**
104		* @see \ArrayAccess::offsetGet()
105		* @param int $offset
106		* @return \BitWasp\Buffertools\BufferInterface
107		*/
108	4080	public function offsetGet($offset)
109		{
110	4080	$index = count($this) + $offset;
111	4080	if (!isset($this->values[$index])) {
112	4	throw new \RuntimeException('No value at this position');
113		}
114
115	4080	return $this->values[$index];
116		}
117
118		/**
119		* @see \ArrayAccess::offsetSet()
120		* @param int $offset
121		* @param BufferInterface $value
122		* @throws \InvalidArgumentException
123		*/
124	69	public function offsetSet($offset, $value)
125		{
126	69	if (!$value instanceof BufferInterface) {
		0 ignored issues – show introduced 2018-11-30 23:28 UTC by Report Bug Copy Issue Report `$value` is always a sub-type of `BitWasp\Buffertools\BufferInterface`. Loading history...
127		throw new \InvalidArgumentException;
128		}
129
130	69	$count = count($this);
131	69	$index = $count + $offset;
132	69	if (isset($this->values[$index])) {
133	69	$this->values[$index] = $value;
134	69	return;
135		}
136
137		if ($index !== $count) {
138		throw new \RuntimeException('Index must be end position');
139		}
140		}
141
142		/**
143		* @see \ArrayAccess::offsetExists()
144		* @param int $offset
145		* @return bool
146		*/
147	1	public function offsetExists($offset)
148		{
149	1	$index = count($this) + $offset;
150	1	return isset($this->values[$index]);
151		}
152
153		/**
154		* @see \ArrayAccess::offsetUnset()
155		* @param int $offset
156		*/
157	86	public function offsetUnset($offset)
158		{
159	86	$count = count($this);
160	86	$index = $count + $offset;
161	86	if (!isset($this->values[$index])) {
162	1	throw new \RuntimeException('Nothing at this position');
163		}
164
165	85	array_splice($this->values, $index, 1);
166	85	}
167
168		/**
169		* @param int $first
170		* @param int $second
171		*/
172	69	public function swap($first, $second)
173		{
174	69	$val1 = $this->offsetGet($first);
175	69	$val2 = $this->offsetGet($second);
176	69	$this->offsetSet($second, $val1);
177	69	$this->offsetSet($first, $val2);
178	69	}
179
180		/**
181		* @param int $offset
182		* @param BufferInterface $value
183		*/
184	14	public function add($offset, $value)
185		{
186	14	$size = count($this);
187	14	$index = $size + $offset;
188	14	if ($index > $size) {
189		throw new \RuntimeException('Invalid add position');
190		}
191
192		// Unwind current values, push provided value, reapply popped values
193	14	$values = [];
194	14	for ($i = $size; $i > $index; $i--) {
195	14	$values[] = $this->pop();
196		}
197
198	14	$this->push($value);
199	14	for ($i = count($values); $i > 0; $i--) {
200	14	$this->push(array_pop($values));
201		}
202	14	}
203
204	3350	public function pop()
205		{
206	3350	$count = count($this);
207	3350	if ($count === 0) {
208	1	throw new \RuntimeException('Cannot pop from empty stack');
209		}
210
211	3349	$value = array_pop($this->values);
212	3349	return $value;
213		}
214
215	4467	public function push($buffer)
216		{
217	4467	$this->values[] = $buffer;
218	4467	}
219
220		/**
221		* @return int
222		*/
223		public function end()
224		{
225		$count = count($this);
226		if ($count === 0) {
227		return 0;
228		}
229
230		return $count - 1;
231		}
232
233		/**
234		* @param int $length
235		* @return $this
236		*/
237	72	public function resize($length)
238		{
239	72	if ($length > count($this)) {
240		throw new \RuntimeException('Invalid start or length');
241		}
242
243	72	while (count($this) > $length) {
244	72	$this->pop();
245		}
246
247	72	return $this;
248		}
249		}
250

Bit-Wasp / bitcoin-php

Push — master ( eabe8c...61f277 )

Stack::key() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like