hiqdev\php\units\AbstractQuantity

Complexity

Total Complexity

22

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

64.29%

Importance

Changes	1
Bugs	1	Features	1

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	create()	0	4	2
A	getCalculator()	0	4	1
A	getQuantity()	0	4	1
A	getUnit()	0	4	1
A	equals()	0	4	1
A	isPositive()	0	4	1
A	isNegative()	0	4	1
A	isConvertible()	0	4	1
A	convert()	0	6	1
A	multiply()	0	6	1
A	divide()	0	6	1
A	ceil()	0	6	1
A	floor()	0	6	1
A	round()	0	6	1
A	absolute()	0	6	1
A	__callStatic()	0	4	1
A	findUnit()	0	4	1
A	compare()	0	6	1
A	add()	0	7	1
A	subtract()	0	7	1

<?php
/**
 * PHP Units of Measure Library.
 *
 * @link      https://github.com/hiqdev/php-units
 * @package   php-units
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\units;

/**
 * Quantity with Unit.
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
abstract class AbstractQuantity implements QuantityInterface
{
    /**
     * @var UnitInterface
     */
    private $unit;

    /**
     * @var float|int|string
     */
    private $quantity;

    /**
     * @var UnitInterface
     * @var float|int|string $quantity
     */
    private function __construct(UnitInterface $unit, $quantity)
    {
        $this->unit = $unit;
        $this->quantity = $quantity;
    }

    /**
     * Creates quantity with same unit.
     * Optimized to return this if same quantity.
     * @var float|int|string
     */
    final protected function create($quantity)
    {
        return $this->quantity === $quantity ? $this : new static($this->unit, $quantity);
    }

    /**
     * {@inheritdoc}
     */
    private function getCalculator()
    {
        return $this->unit->getCalculator();
    }

    /**
     * {@inheritdoc}
     */
    final public function getQuantity()
    {
        return $this->quantity;
    }

    /**
     * {@inheritdoc}
     */
    final public function getUnit()
    {
        return $this->unit;
    }

    /**
     * {@inheritdoc}
     */
    final public function compare(QuantityInterface $other)
    {
        $arg = $other->convert($this->unit)->getQuantity();

        return $this->getCalculator()->compare($this->quantity, $arg);
    }

    /**
     * {@inheritdoc}
     */
    final public function equals(QuantityInterface $other)
    {
        return $this->compare($other) === 0;
    }

    /**
     * {@inheritdoc}
     */
    final public function isPositive()
    {
        return $this->quantity > 0;
    }

    /**
     * {@inheritdoc}
     */
    final public function isNegative()
    {
        return $this->quantity < 0;
    }

    /**
     * {@inheritdoc}
     */
    final public function isConvertible(UnitInterface $unit)
    {
        return $this->unit->isConvertible($unit);

The return type of return $this->unit->isConvertible($unit); (boolean) is incompatible with the return type declared by the interface hiqdev\php\units\QuantityInterface::isConvertible of type hiqdev\php\units\QuantityInterface.

    }

    /**
     * {@inheritdoc}
     */
    final public function convert(UnitInterface $unit)
    {
        $res = $this->unit->convert($unit, $this->quantity);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function add(QuantityInterface $addend)
    {
        $arg = $addend->convert($this->unit)->getQuantity();
        $res = $this->getCalculator()->add($this->quantity, $arg);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function subtract(QuantityInterface $subtrahend)
    {
        $arg = $subtrahend->convert($this->unit)->getQuantity();
        $res = $this->getCalculator()->subtract($this->quantity, $arg);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function multiply($multiplier)
    {
        $res = $this->getCalculator()->multiply($this->quantity, $multiplier);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function divide($divisor)
    {
        $res = $this->getCalculator()->divide($this->quantity, $divisor);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function ceil()
    {
        $res = $this->getCalculator()->ceil($this->quantity);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function floor()
    {
        $res = $this->getCalculator()->floor($this->quantity);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function round($roundingMode)
    {
        $res = $this->getCalculator()->round($this->quantity, $roundingMode);

        return $this->create($res);
    }

    /**
     * {@inheritdoc}
     */
    final public function absolute()
    {
        $res = $this->getCalculator()->absolute($this->quantity);

        return $this->create($res);
    }

    final public static function __callStatic($unit, $args)
    {
        return new static(static::findUnit($unit), $args[0]);
    }

    /**
     * Returns unit for given unit name.
     * The only function to change in child classes.
     * XXX Should be defined as abstract but `abstract static` is not supported in PHP5.
     * @param string $name

There is no parameter named $name. Was it maybe removed?

     * @throws InvalidConfigException
     * @return UnitInterface
     */
    protected static function findUnit($unit)
    {
        throw new InvalidConfigException('getUnit method must be redefined');
    }
}