Ds\Traits\Capacity

Complexity

Total Complexity

15

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	capacity()	0	4	1
A	allocate()	0	4	1
A	getGrowthFactor()	0	4	1
A	getDecayFactor()	0	4	1
A	getTruncateThreshold()	0	4	1
A	checkCapacity()	0	10	3
A	ensureCapacity()	0	6	2
A	shouldIncreaseCapacity()	0	4	1
A	nextCapacity()	0	4	1
A	increaseCapacity()	0	7	1
A	decreaseCapacity()	0	7	1
A	shouldDecreaseCapacity()	0	4	1

<?php
namespace Ds\Traits;

use Ds\Deque;

/**
 * Common to structures that deal with an internal capacity. While none of the
 * PHP implementations actually make use of a capacity, it's important to keep
 * consistent with the extension.
 */
trait Capacity
{
    /**
     * @var integer internal capacity
     */
    private $capacity = self::MIN_CAPACITY;

    /**
     * Returns the current capacity.
     *
     * @return int
     */
    public function capacity(): int
    {
        return $this->capacity;
    }

    /**
     * Ensures that enough memory is allocated for a specified capacity. This
     * potentially reduces the number of reallocations as the size increases.
     *
     * @param int $capacity The number of values for which capacity should be
     *                      allocated. Capacity will stay the same if this value
     *                      is less than or equal to the current capacity.
     */
    public function allocate(int $capacity)
    {
        $this->capacity = max($capacity, $this->capacity);
    }

    /**
     * @return float the structures growth factor.
     */
    protected function getGrowthFactor(): float
    {
        return 2;
    }

    /**
     * @return float to multiply by when decreasing capacity.
     */
    protected function getDecayFactor(): float
    {
        return 0.5;
    }

    /**
     * @return float the ratio between size and capacity when capacity should be
     *               decreased.
     */
    protected function getTruncateThreshold(): float
    {
        return 0.25;
    }

    /**
     * Checks and adjusts capacity if required.
     */
    protected function checkCapacity()
    {
        if ($this->shouldIncreaseCapacity()) {
            $this->increaseCapacity();
        } else {
            if ($this->shouldDecreaseCapacity()) {
                $this->decreaseCapacity();
            }
        }
    }

    /**
     * @param int $total
     */
    protected function ensureCapacity(int $total)
    {
        if ($total > $this->capacity()) {
            $this->capacity = max($total, $this->nextCapacity());
        }
    }

    /**
     * @return bool whether capacity should be increased.
     */
    protected function shouldIncreaseCapacity(): bool
    {
        return $this->count() >= $this->capacity();

It seems like count() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    protected function nextCapacity(): int
    {
        return $this->capacity() * $this->getGrowthFactor();
    }

    /**
     * Called when capacity should be increased to accommodate new values.
     */
    protected function increaseCapacity()
    {
        $this->capacity = max(
            $this->count(),

It seems like count() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $this->nextCapacity()
        );
    }

    /**
     * Called when capacity should be decrease if it drops below a threshold.
     */
    protected function decreaseCapacity()
    {
        $this->capacity = max(
            self::MIN_CAPACITY,
            $this->capacity()  * $this->getDecayFactor()
        );
    }

    /**
     * @return bool whether capacity should be increased.
     */
    protected function shouldDecreaseCapacity(): bool
    {
        return count($this) <= $this->capacity() * $this->getTruncateThreshold();
    }
}