Tree::__construct() - Code Metrics - MartanLV/koki - Measure and Improve Code Quality continuously with Scrutinizer

Tree::__construct() A
last analyzed 2018-02-13 06:27 UTC

↳ Parent: Tree

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	3
nc	2
nop	2

<?php

declare(strict_types=1);

namespace MartanLV\Koki;

/**
 * Augmented tree
 * Class StaticTree.
 *
 * @author yourname
 */
class Tree extends Node
{
    public $root;

    /**
     * undocumented function.
     *
     * @param $intervals array of Interval
     *
     * @return void
     */
    public function __construct(array $intervals = [], bool $preSorted = false)
    {
        !$preSorted && usort($intervals, function (IntervalInterface $i0, IntervalInterface $i) {
            return $i0->getStart() <=> $i->getStart();
        });
        $this->root = $this->toTree($intervals);
    }

    /**
     * An augmented tree can be built from a simple ordered tree,
     * for example a binary search tree or self-balancing binary search tree,
     * ordered by the 'low' values of the intervals.
     */
    public function toTree(array $intervals)
    {
        $max = 0;
        $len = count($intervals);
        $mid = (int) floor($len / 2);

        if (!$len) {
            return;
        }

        array_walk($intervals, function (IntervalInterface $el) use (&$max) {
            if ($max < $el->getEnd()) {
                $max = $el->getEnd();
            }
        });
        $l_intervals = array_splice($intervals, 0, $mid);
        $r_intervals = array_splice($intervals, -$mid);
        $interval = $intervals ? reset($intervals) : array_pop($l_intervals);
        $interval = $interval ?? array_pop($r_intervals);

        $node = new Node(
            $interval,
            $this->toTree($l_intervals),
            $this->toTree($r_intervals),
            $max
        );

        $node->root = &$this;

        return $node;
    }

    /**
     * returns intervals that exclusively fall within range given
     * to retrieve eather bound inclusevely, just modify parameters.
     *
     * @return void
     */
    public function select(int $low, int $high): array
    {
        return $this->root ? $this->root->select($low, $high) : [];

    }

    public function selectNode(int $low, int $high): array
    {
        return $this->root ? $this->root->selectNode($low, $high) : [];
    }

    /**
     * rebalance messed up tree overall.
     */
    public function balance()
    {
        // todo
    }

    /**
     * understandable var dump.
     */
    public function __debugInfo()
    {
        $arr = $this->all();

        usort($arr, function (IntervalInterface $i0, IntervalInterface $i) {
            return $i0->getStart() <=> $i->getStart();
        });

        return $arr;
    }

    public function yieldInterSelect(int $low, int $high)
    {
        return $this->root ? $this->root->yieldInterSelect($low, $high) : [];
    }

    public function interSelectNode(int $low, int $high): array
    {
        return $this->root ? $this->root->interSelectNode($low, $high) : [];
    }

    public function interSelect(int $low, int $high): array
    {
        return $this->root ? $this->root->interSelect($low, $high) : [];
    }

    public function yieldSelect(int $low, int $high)
    {
        return $this->root ? $this->root->yieldSelect($low, $high) : [];
    }

    /**
     * @return void
     */
    public function all(): array
    {
        return $this->root ? $this->root->all() : [];

    }

    /**
     * undocumented function.
     *
     * @return void
     */
    public function yieldAll()
    {
        return $this->root ? $this->root->yieldAll() : [];
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    public function removeRegion(int $low, int $high)
    {
        if (!$this->root) {
            return [];
        }
        foreach ($this->interSelectNode($low, $high) as $node) {
            $this->remove($node);
        }
    }

    public function remove(IntervalInterface $i)
    {
        if (!$i->left && !$i->right) {

            if ($i->root) {

                $i->root = null;
            }

            return;
        }

        if ($i->left && $i->right) {
            // todo
            return;
        }
        if ($i->left) {
            $i->interval = &$i->left->interval;

            $i->left = null;
        }

        if ($i->right) {
        }

        if ($this->max > $i->getEnd()) {
            if ($this->left) {
                $this->left->add($i);
            } else {
                $this->left = new Node($i);
            }
        } else {
            $this->max = $i->getEnd();
            if ($this->right) {
                $this->right->add($i);
            } else {
                $this->right = new Node($i);
            }
        }

        return;
        if (!$this->root) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            return [];
        }
        $this->root->remove($i);
    }

    public function add(IntervalInterface $i)
    {
        if (!$this->root) {
            $this->root = new Node($i);

            return;
        }
        $this->root->add($i);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace MartanLV\Koki;
6
7			/**
8			* Augmented tree
9			* Class StaticTree.
10			*
11			* @author yourname
12			*/
13			class Tree extends Node
14			{
15			public $root;
16
17			/**
18			* undocumented function.
19			*
20			* @param $intervals array of Interval
21			*
22			* @return void
23			*/
24			public function __construct(array $intervals = [], bool $preSorted = false)
25			{
26			!$preSorted && usort($intervals, function (IntervalInterface $i0, IntervalInterface $i) {
27			return $i0->getStart() <=> $i->getStart();
28			});
29			$this->root = $this->toTree($intervals);
30			}
31
32			/**
33			* An augmented tree can be built from a simple ordered tree,
34			* for example a binary search tree or self-balancing binary search tree,
35			* ordered by the 'low' values of the intervals.
36			*/
37			public function toTree(array $intervals)
38			{
39			$max = 0;
40			$len = count($intervals);
41			$mid = (int) floor($len / 2);
42
43			if (!$len) {
44			return;
45			}
46
47			array_walk($intervals, function (IntervalInterface $el) use (&$max) {
48			if ($max < $el->getEnd()) {
49			$max = $el->getEnd();
50			}
51			});
52			$l_intervals = array_splice($intervals, 0, $mid);
53			$r_intervals = array_splice($intervals, -$mid);
54			$interval = $intervals ? reset($intervals) : array_pop($l_intervals);
55			$interval = $interval ?? array_pop($r_intervals);
56
57			$node = new Node(
58			$interval,
59			$this->toTree($l_intervals),
60			$this->toTree($r_intervals),
61			$max
62			);
63
64			$node->root = &$this;
65
66			return $node;
67			}
68
69			/**
70			* returns intervals that exclusively fall within range given
71			* to retrieve eather bound inclusevely, just modify parameters.
72			*
73			* @return void
74			*/
75			public function select(int $low, int $high): array
76			{
77			return $this->root ? $this->root->select($low, $high) : [];
			0 ignored issues – show Bug Best Practice introduced 2017-12-15 21:37 UTC by Report Bug Copy Issue Report The expression `return $this->root ? $th...($low, $high) : array()` returns the type `array` which is incompatible with the documented return type `void`. Loading history...
78			}
79
80			public function selectNode(int $low, int $high): array
81			{
82			return $this->root ? $this->root->selectNode($low, $high) : [];
83			}
84
85			/**
86			* rebalance messed up tree overall.
87			*/
88			public function balance()
89			{
90			// todo
91			}
92
93			/**
94			* understandable var dump.
95			*/
96			public function __debugInfo()
97			{
98			$arr = $this->all();
99
100			usort($arr, function (IntervalInterface $i0, IntervalInterface $i) {
101			return $i0->getStart() <=> $i->getStart();
102			});
103
104			return $arr;
105			}
106
107			public function yieldInterSelect(int $low, int $high)
108			{
109			return $this->root ? $this->root->yieldInterSelect($low, $high) : [];
110			}
111
112			public function interSelectNode(int $low, int $high): array
113			{
114			return $this->root ? $this->root->interSelectNode($low, $high) : [];
115			}
116
117			public function interSelect(int $low, int $high): array
118			{
119			return $this->root ? $this->root->interSelect($low, $high) : [];
120			}
121
122			public function yieldSelect(int $low, int $high)
123			{
124			return $this->root ? $this->root->yieldSelect($low, $high) : [];
125			}
126
127			/**
128			* @return void
129			*/
130			public function all(): array
131			{
132			return $this->root ? $this->root->all() : [];
			0 ignored issues – show Bug Best Practice introduced 2017-12-15 21:37 UTC by Report Bug Copy Issue Report The expression `return $this->root ? $this->root->all() : array()` returns the type `array` which is incompatible with the documented return type `void`. Loading history...
133			}
134
135			/**
136			* undocumented function.
137			*
138			* @return void
139			*/
140			public function yieldAll()
141			{
142			return $this->root ? $this->root->yieldAll() : [];
			0 ignored issues – show Bug Best Practice introduced 2017-12-15 21:37 UTC by Report Bug Copy Issue Report The expression `return $this->root ? $th...t->yieldAll() : array()` returns the type `array` which is incompatible with the documented return type `void`. Loading history... Bug introduced 2017-12-15 21:37 UTC by Report Bug Copy Issue Report Are you sure the usage of `$this->root->yieldAll()` targeting `MartanLV\Koki\Node::yieldAll()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
143			}
144
145			public function removeRegion(int $low, int $high)
146			{
147			if (!$this->root) {
148			return [];
149			}
150			foreach ($this->interSelectNode($low, $high) as $node) {
151			$this->remove($node);
152			}
153			}
154
155			public function remove(IntervalInterface $i)
156			{
157			if (!$i->left && !$i->right) {
			0 ignored issues – show Bug introduced 2018-02-13 05:26 UTC by Report Bug Copy Issue Report Accessing `left` on the interface `MartanLV\Koki\IntervalInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history... Bug introduced 2018-02-13 05:26 UTC by Report Bug Copy Issue Report Accessing `right` on the interface `MartanLV\Koki\IntervalInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
158			if ($i->root) {
			0 ignored issues – show Bug introduced 2018-02-13 05:26 UTC by Report Bug Copy Issue Report Accessing `root` on the interface `MartanLV\Koki\IntervalInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
159			$i->root = null;
160			}
161
162			return;
163			}
164
165			if ($i->left && $i->right) {
166			// todo
167			return;
168			}
169			if ($i->left) {
170			$i->interval = &$i->left->interval;
			0 ignored issues – show Bug introduced 2018-02-13 05:26 UTC by Report Bug Copy Issue Report Accessing `interval` on the interface `MartanLV\Koki\IntervalInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
171			$i->left = null;
172			}
173
174			if ($i->right) {
175			}
176
177			if ($this->max > $i->getEnd()) {
178			if ($this->left) {
179			$this->left->add($i);
180			} else {
181			$this->left = new Node($i);
182			}
183			} else {
184			$this->max = $i->getEnd();
185			if ($this->right) {
186			$this->right->add($i);
187			} else {
188			$this->right = new Node($i);
189			}
190			}
191
192			return;
193			if (!$this->root) {
			0 ignored issues – show Unused Code introduced 2018-02-13 05:26 UTC by Report Bug Copy Issue Report `IfNode` is not reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
194			return [];
195			}
196			$this->root->remove($i);
197			}
198
199			public function add(IntervalInterface $i)
200			{
201			if (!$this->root) {
202			$this->root = new Node($i);
203
204			return;
205			}
206			$this->root->add($i);
207			}
208			}
209

MartanLV / koki

Tree::__construct() A last analyzed 2018-02-13 06:27 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Tree::__construct() A
last analyzed 2018-02-13 06:27 UTC