Ds\Traits\Capacity

Complexity

Total Complexity

12

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

0%

Importance

Changes

0

10 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	increaseCapacity()	0	4	1
A	decreaseCapacity()	0	4	1
A	shouldDecreaseCapacity()	0	4	1
A	shouldIncreaseCapacity()	0	4	1

<?php
namespace Ds\Traits;

/**
 * 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 the structures growth factor.

Should the return type not be double?

     */
    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();
            }
        }
    }

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

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

This line exceeds maximum limit of 80 characters; contains 90 characters

    }

    /**
     * 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());

This line exceeds maximum limit of 80 characters; contains 94 characters

    }

    /**
     * @return whether capacity should be increased.

Should the return type not be boolean?

     */
    protected function shouldDecreaseCapacity(): bool
    {
        return count($this) <= $this->capacity * $this->getTruncateThreshold();
    }

    /**
     * @return whether capacity should be increased.

Should the return type not be boolean?

     */
    protected function shouldIncreaseCapacity(): bool
    {
        return count($this) >= $this->capacity;
    }
}