MartanLV\Koki\Tree

Complexity

Total Complexity

41

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	interSelectNode()	0	3	2
A	yieldAll()	0	3	2
A	interSelect()	0	3	2
A	select()	0	3	2
A	yieldSelect()	0	3	2
A	removeRegion()	0	7	3
A	yieldInterSelect()	0	3	2
C	remove()	0	42	12
A	__construct()	0	6	2
A	__debugInfo()	0	9	1
A	add()	0	8	2
B	toTree()	0	30	4
A	selectNode()	0	3	2
A	balance()	0	2	1
A	all()	0	3	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) : [];

The expression return $this->root ? $this->root->select($low, $high) : array() returns the type array which is incompatible with the documented return type void.

    }

    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() : [];

The expression return $this->root ? $this->root->all() : array() returns the type array which is incompatible with the documented return type void.

    }

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

The expression return $this->root ? $this->root->yieldAll() : array() returns the type array which is incompatible with the documented return type void.

Are you sure the usage of $this->root->yieldAll() targeting MartanLV\Koki\Node::yieldAll() seems to always return null.

    }

    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) {

Accessing left on the interface MartanLV\Koki\IntervalInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing right on the interface MartanLV\Koki\IntervalInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            if ($i->root) {

Accessing root on the interface MartanLV\Koki\IntervalInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                $i->root = null;
            }

            return;
        }

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

Accessing interval on the interface MartanLV\Koki\IntervalInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $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) {

IfNode is not reachable.

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

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

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