ScriptWitness::__construct() - Code Metrics - Inspection of "[BC BREAK] Remove Collection classes, refactor Scr..." - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#825)

by thomas

created 2019-12-10 02:37 UTC

ScriptWitness::__construct() A

↳ Parent: ScriptWitness

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Script;

use BitWasp\Bitcoin\Collection\StaticBufferCollection;
filter:
    dependency_paths: ["lib/*"]
use BitWasp\Bitcoin\Serializer\Script\ScriptWitnessSerializer;
use BitWasp\Buffertools\BufferInterface;

class ScriptWitness implements ScriptWitnessInterface
{
    /**
     * @var BufferInterface[]
     */
    protected $set = [];

    /**
     * @var int
     */
    protected $position = 0;

    /**
     * StaticBufferCollection constructor.
     * @param BufferInterface ...$values
     */
    public function __construct(BufferInterface... $values)
    {
        $this->set = $values;
    }

    /**
     * @param ScriptWitnessInterface $witness
     * @return bool
     */
    public function equals(ScriptWitnessInterface $witness): bool
    {
        $nStack = count($this);
        if ($nStack !== count($witness)) {
            return false;
        }

        for ($i = 0; $i < $nStack; $i++) {
            if (false === $this->offsetGet($i)->equals($witness->offsetGet($i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return BufferInterface
     */
    public function getBuffer(): BufferInterface
    {
        return (new ScriptWitnessSerializer())->serialize($this);
    }

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

    /**
     * @param int $start
     * @param int $length
     * @return ScriptWitnessInterface
     */
    public function slice(int $start, int $length): ScriptWitnessInterface
    {
        $end = count($this->set);
        if ($start > $end || $length > $end) {
            throw new \RuntimeException('Invalid start or length');
        }

        $sliced = array_slice($this->set, $start, $length);
        return new static(...$sliced);
    }

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

    /**
     * @return BufferInterface
     */
    public function bottom(): BufferInterface
    {
        if (count($this->set) === 0) {
            throw new \RuntimeException('No bottom for empty collection');
        }

        return $this->offsetGet(count($this) - 1);
    }

    /**
     * @return BufferInterface
     */
    public function top(): BufferInterface
    {
        if (count($this->set) === 0) {
            throw new \RuntimeException('No top for empty collection');
        }

        return $this->offsetGet(0);
    }

    /**
     * @return bool
     */
    public function isNull(): bool
    {
        return count($this->set) === 0;
    }

    /**
     * @return void
     */
    public function rewind()
    {
        $this->position = 0;
    }

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

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

    /**
     * @return void
     */
    public function next()
    {
        ++$this->position;
    }

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

    /**
     * @param int $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->set);
    }

    /**
     * @param int $offset
     */
    public function offsetUnset($offset)
    {
        throw new \RuntimeException('ScriptWitness is immutable');
    }

    /**
     * @param int $offset
     * @return BufferInterface
     */
    public function offsetGet($offset)
    {
        if (!array_key_exists($offset, $this->set)) {
            throw new \OutOfRangeException('Nothing found at this offset');
        }

        return $this->set[$offset];
    }

    /**
     * @param int $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value)
    {
        throw new \RuntimeException('ScriptWitness is immutable');
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Bitcoin\Script;
6
7		use BitWasp\Bitcoin\Collection\StaticBufferCollection;
		0 ignored issues – show Bug introduced 2019-12-10 03:06 UTC by Report Bug Copy Issue Report The type `BitWasp\Bitcoin\Collection\StaticBufferCollection` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
8		use BitWasp\Bitcoin\Serializer\Script\ScriptWitnessSerializer;
9		use BitWasp\Buffertools\BufferInterface;
10
11		class ScriptWitness implements ScriptWitnessInterface
12		{
13		/**
14		* @var BufferInterface[]
15		*/
16		protected $set = [];
17
18		/**
19		* @var int
20		*/
21		protected $position = 0;
22
23		/**
24		* StaticBufferCollection constructor.
25		* @param BufferInterface ...$values
26		*/
27	362	public function __construct(BufferInterface... $values)
28		{
29	362	$this->set = $values;
30	362	}
31
32		/**
33		* @param ScriptWitnessInterface $witness
34		* @return bool
35		*/
36	50	public function equals(ScriptWitnessInterface $witness): bool
37		{
38	50	$nStack = count($this);
39	50	if ($nStack !== count($witness)) {
40		return false;
41		}
42
43	50	for ($i = 0; $i < $nStack; $i++) {
44	22	if (false === $this->offsetGet($i)->equals($witness->offsetGet($i))) {
45		return false;
46		}
47		}
48
49	50	return true;
50		}
51
52		/**
53		* @return BufferInterface
54		*/
55		public function getBuffer(): BufferInterface
56		{
57		return (new ScriptWitnessSerializer())->serialize($this);
58		}
59
60		/**
61		* @return BufferInterface[]
62		*/
63	49	public function all(): array
64		{
65	49	return $this->set;
66		}
67
68		/**
69		* @param int $start
70		* @param int $length
71		* @return ScriptWitnessInterface
72		*/
73	228	public function slice(int $start, int $length): ScriptWitnessInterface
74		{
75	228	$end = count($this->set);
76	228	if ($start > $end \|\| $length > $end) {
77		throw new \RuntimeException('Invalid start or length');
78		}
79
80	228	$sliced = array_slice($this->set, $start, $length);
81	228	return new static(...$sliced);
82		}
83
84		/**
85		* @return int
86		*/
87	453	public function count(): int
88		{
89	453	return count($this->set);
90		}
91
92		/**
93		* @return BufferInterface
94		*/
95	24	public function bottom(): BufferInterface
96		{
97	24	if (count($this->set) === 0) {
98		throw new \RuntimeException('No bottom for empty collection');
99		}
100
101	24	return $this->offsetGet(count($this) - 1);
102		}
103
104		/**
105		* @return BufferInterface
106		*/
107		public function top(): BufferInterface
108		{
109		if (count($this->set) === 0) {
110		throw new \RuntimeException('No top for empty collection');
111		}
112
113		return $this->offsetGet(0);
114		}
115
116		/**
117		* @return bool
118		*/
119	44	public function isNull(): bool
120		{
121	44	return count($this->set) === 0;
122		}
123
124		/**
125		* @return void
126		*/
127	374	public function rewind()
128		{
129	374	$this->position = 0;
130	374	}
131
132		/**
133		* @return BufferInterface
134		*/
135	339	public function current(): BufferInterface
136		{
137	339	return $this->set[$this->position];
138		}
139
140		/**
141		* @return int
142		*/
143		public function key(): int
144		{
145		return $this->position;
146		}
147
148		/**
149		* @return void
150		*/
151	338	public function next()
152		{
153	338	++$this->position;
154	338	}
155
156		/**
157		* @return bool
158		*/
159	374	public function valid(): bool
160		{
161	374	return isset($this->set[$this->position]);
162		}
163
164		/**
165		* @param int $offset
166		* @return bool
167		*/
168		public function offsetExists($offset)
169		{
170		return array_key_exists($offset, $this->set);
171		}
172
173		/**
174		* @param int $offset
175		*/
176		public function offsetUnset($offset)
177		{
178		throw new \RuntimeException('ScriptWitness is immutable');
179		}
180
181		/**
182		* @param int $offset
183		* @return BufferInterface
184		*/
185	264	public function offsetGet($offset)
186		{
187	264	if (!array_key_exists($offset, $this->set)) {
188	2	throw new \OutOfRangeException('Nothing found at this offset');
189		}
190
191	262	return $this->set[$offset];
192		}
193
194		/**
195		* @param int $offset
196		* @param mixed $value
197		*/
198		public function offsetSet($offset, $value)
199		{
200		throw new \RuntimeException('ScriptWitness is immutable');
201		}
202		}
203

Bit-Wasp / bitcoin-php

Pull Request — master (#825)

ScriptWitness::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like