ItemList::fromArray() - Code Metrics - Inspection of "Measure branch and path coverage from the testsuit..." - dvdoug/BoxPacker - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 09012b...794d70 )

by Doug

created 2020-08-07 17:41 UTC

ItemList::fromArray() A

↳ Parent: ItemList

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

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

<?php
/**
 * Box packing (3D bin packing, knapsack problem).
 *
 * @author Doug Wright
 */
declare(strict_types=1);

namespace DVDoug\BoxPacker;

use function array_key_last;
use function array_pop;
use function array_reverse;
use function array_slice;
use ArrayIterator;
use function count;
use Countable;
use function end;
use IteratorAggregate;
use Traversable;
use function usort;

/**
 * List of items to be packed, ordered by volume.
 *
 * @author Doug Wright
 */
class ItemList implements Countable, IteratorAggregate
{
    /**
     * List containing items.
     *
     * @var Item[]
     */
    private $list = [];

    /**
     * Has this list already been sorted?
     *
     * @var bool
     */
    private $isSorted = false;

    /**
     * Does this list contain constrained items?
     *
     * @var bool
     */
    private $hasConstrainedItems;

    /**
     * Does this list contain items which cannot be rotated?
     *
     * @var bool
     */
    private $hasNoRotationItems;

    /**
     * Do a bulk create.
     *
     * @param  Item[]   $items
     * @return ItemList
     */
    public static function fromArray(array $items, bool $preSorted = false): self
    {
        $list = new static();
        $list->list = array_reverse($items); // internal sort is largest at the end
        $list->isSorted = $preSorted;

        return $list;
    }

    public function insert(Item $item): void
    {
        $this->list[] = $item;
        $this->isSorted = false;
        $this->hasConstrainedItems = $this->hasConstrainedItems || $item instanceof ConstrainedPlacementItem;
        $this->hasNoRotationItems = $this->hasNoRotationItems || $item->getAllowedRotations() === Item::ROTATION_NEVER;
    }

    /**
     * Remove item from list.
     */
    public function remove(Item $item): void
    {
        if (!$this->isSorted) {
            usort($this->list, [$this, 'compare']);
            $this->isSorted = true;
        }

        end($this->list);
        do {
            if (current($this->list) === $item) {
                unset($this->list[key($this->list)]);

                return;
            }
        } while (prev($this->list) !== false);
    }

    public function removePackedItems(PackedItemList $packedItemList): void
    {
        foreach ($packedItemList as $packedItem) {
            end($this->list);
            do {
                if (current($this->list) === $packedItem->getItem()) {
                    unset($this->list[key($this->list)]);

                    break;
                }
            } while (prev($this->list) !== false);
        }
    }

    /**
     * @internal
     */
    public function extract(): Item
    {
        if (!$this->isSorted) {
            usort($this->list, [$this, 'compare']);
            $this->isSorted = true;
        }

        return array_pop($this->list);
    }

    /**
     * @internal
     */
    public function top(): Item
    {
        if (!$this->isSorted) {
            usort($this->list, [$this, 'compare']);
            $this->isSorted = true;
        }

        return $this->list[array_key_last($this->list)];
    }

    /**
     * @internal
     * @return ItemList
     */
    public function topN(int $n): self
    {
        if (!$this->isSorted) {
            usort($this->list, [$this, 'compare']);
            $this->isSorted = true;
        }

        $topNList = new self();
        $topNList->list = array_slice($this->list, -$n, $n);
        $topNList->isSorted = true;

        return $topNList;
    }

    /**
     * @return Traversable|Item[]
     */
    public function getIterator(): Traversable
    {
        if (!$this->isSorted) {
            usort($this->list, [$this, 'compare']);
            $this->isSorted = true;
        }

        return new ArrayIterator(array_reverse($this->list));
    }

    /**
     * Number of items in list.
     */
    public function count(): int
    {
        return count($this->list);
    }

    /**
     * Does this list contain items with constrained placement criteria.
     */
    public function hasConstrainedItems(): bool
    {
        if (!isset($this->hasConstrainedItems)) {
            $this->hasConstrainedItems = false;
            foreach ($this->list as $item) {
                if ($item instanceof ConstrainedPlacementItem) {
                    $this->hasConstrainedItems = true;
                    break;
                }
            }
        }

        return $this->hasConstrainedItems;
    }

    /**
     * Does this list contain items which cannot be rotated.
     */
    public function hasNoRotationItems(): bool
    {
        if (!isset($this->hasNoRotationItems)) {
            $this->hasNoRotationItems = false;
            foreach ($this->list as $item) {
                if ($item->getAllowedRotations() === Item::ROTATION_NEVER) {
                    $this->hasNoRotationItems = true;
                    break;
                }
            }
        }

        return $this->hasNoRotationItems;
    }

    private static function compare(Item $itemA, Item $itemB): int
    {
        $volumeDecider = $itemA->getWidth() * $itemA->getLength() * $itemA->getDepth() <=> $itemB->getWidth() * $itemB->getLength() * $itemB->getDepth();
        if ($volumeDecider !== 0) {
            return $volumeDecider;
        }
        $weightDecider = $itemA->getWeight() - $itemB->getWeight();
        if ($weightDecider !== 0) {
            return $weightDecider;
        }

        return $itemB->getDescription() <=> $itemA->getDescription();
    }
}


1		<?php
2		/**
3		* Box packing (3D bin packing, knapsack problem).
4		*
5		* @author Doug Wright
6		*/
7		declare(strict_types=1);
8
9		namespace DVDoug\BoxPacker;
10
11		use function array_key_last;
12		use function array_pop;
13		use function array_reverse;
14		use function array_slice;
15		use ArrayIterator;
16		use function count;
17		use Countable;
18		use function end;
19		use IteratorAggregate;
20		use Traversable;
21		use function usort;
22
23		/**
24		* List of items to be packed, ordered by volume.
25		*
26		* @author Doug Wright
27		*/
28		class ItemList implements Countable, IteratorAggregate
29		{
30		/**
31		* List containing items.
32		*
33		* @var Item[]
34		*/
35		private $list = [];
36
37		/**
38		* Has this list already been sorted?
39		*
40		* @var bool
41		*/
42		private $isSorted = false;
43
44		/**
45		* Does this list contain constrained items?
46		*
47		* @var bool
48		*/
49		private $hasConstrainedItems;
50
51		/**
52		* Does this list contain items which cannot be rotated?
53		*
54		* @var bool
55		*/
56		private $hasNoRotationItems;
57
58		/**
59		* Do a bulk create.
60		*
61		* @param Item[] $items
62		* @return ItemList
63		*/
64	41	public static function fromArray(array $items, bool $preSorted = false): self
65		{
66	41	$list = new static();
67	41	$list->list = array_reverse($items); // internal sort is largest at the end
68	41	$list->isSorted = $preSorted;
69
70	41	return $list;
71		}
72
73	42	public function insert(Item $item): void
74		{
75	42	$this->list[] = $item;
76	42	$this->isSorted = false;
77	42	$this->hasConstrainedItems = $this->hasConstrainedItems \|\| $item instanceof ConstrainedPlacementItem;
78	42	$this->hasNoRotationItems = $this->hasNoRotationItems \|\| $item->getAllowedRotations() === Item::ROTATION_NEVER;
79	42	}
80
81		/**
82		* Remove item from list.
83		*/
84	2	public function remove(Item $item): void
85		{
86	2	if (!$this->isSorted) {
87	2	usort($this->list, [$this, 'compare']);
88	2	$this->isSorted = true;
89		}
90
91	2	end($this->list);
92		do {
93	2	if (current($this->list) === $item) {
94	2	unset($this->list[key($this->list)]);
95
96	2	return;
97		}
98		} while (prev($this->list) !== false);
99		}
100
101	23	public function removePackedItems(PackedItemList $packedItemList): void
102		{
103	23	foreach ($packedItemList as $packedItem) {
104	18	end($this->list);
105		do {
106	18	if (current($this->list) === $packedItem->getItem()) {
107	18	unset($this->list[key($this->list)]);
108
109	18	break;
110		}
111	1	} while (prev($this->list) !== false);
112		}
113	23	}
114
115		/**
116		* @internal
117		*/
118	41	public function extract(): Item
119		{
120	41	if (!$this->isSorted) {
121	30	usort($this->list, [$this, 'compare']);
122	30	$this->isSorted = true;
123		}
124
125	41	return array_pop($this->list);
126		}
127
128		/**
129		* @internal
130		*/
131	35	public function top(): Item
132		{
133	35	if (!$this->isSorted) {
134		usort($this->list, [$this, 'compare']);
135		$this->isSorted = true;
136		}
137
138	35	return $this->list[array_key_last($this->list)];
139		}
140
141		/**
142		* @internal
143		* @return ItemList
144		*/
145	33	public function topN(int $n): self
146		{
147	33	if (!$this->isSorted) {
148		usort($this->list, [$this, 'compare']);
149		$this->isSorted = true;
150		}
151
152	33	$topNList = new self();
153	33	$topNList->list = array_slice($this->list, -$n, $n);
154	33	$topNList->isSorted = true;
155
156	33	return $topNList;
157		}
158
159		/**
160		* @return Traversable\|Item[]
161		*/
162	42	public function getIterator(): Traversable
163		{
164	42	if (!$this->isSorted) {
165	12	usort($this->list, [$this, 'compare']);
166	12	$this->isSorted = true;
167		}
168
169	42	return new ArrayIterator(array_reverse($this->list));
170		}
171
172		/**
173		* Number of items in list.
174		*/
175	42	public function count(): int
176		{
177	42	return count($this->list);
178		}
179
180		/**
181		* Does this list contain items with constrained placement criteria.
182		*/
183	41	public function hasConstrainedItems(): bool
184		{
185	41	if (!isset($this->hasConstrainedItems)) {
186	17	$this->hasConstrainedItems = false;
187	17	foreach ($this->list as $item) {
188	17	if ($item instanceof ConstrainedPlacementItem) {
189		$this->hasConstrainedItems = true;
190		break;
191		}
192		}
193		}
194
195	41	return $this->hasConstrainedItems;
196		}
197
198		/**
199		* Does this list contain items which cannot be rotated.
200		*/
201	41	public function hasNoRotationItems(): bool
202		{
203	41	if (!isset($this->hasNoRotationItems)) {
204	17	$this->hasNoRotationItems = false;
205	17	foreach ($this->list as $item) {
206	17	if ($item->getAllowedRotations() === Item::ROTATION_NEVER) {
207		$this->hasNoRotationItems = true;
208		break;
209		}
210		}
211		}
212
213	41	return $this->hasNoRotationItems;
214		}
215
216	40	private static function compare(Item $itemA, Item $itemB): int
217		{
218	40	$volumeDecider = $itemA->getWidth() * $itemA->getLength() * $itemA->getDepth() <=> $itemB->getWidth() * $itemB->getLength() * $itemB->getDepth();
219	40	if ($volumeDecider !== 0) {
220	23	return $volumeDecider;
221		}
222	36	$weightDecider = $itemA->getWeight() - $itemB->getWeight();
223	36	if ($weightDecider !== 0) {
224	4	return $weightDecider;
225		}
226
227	32	return $itemB->getDescription() <=> $itemA->getDescription();
228		}
229		}
230

dvdoug / BoxPacker

Push — master ( 09012b...794d70 )

ItemList::fromArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like